Skip to content

Commit d40f2ed

Browse files
owencaowenca
committed
[clang-format] Simplify the AfterPlacementOperator option
Change AfterPlacementOperator to a boolean. Also add SBPO_None for never inserting a space before a left parenthesis and deprecate SBPO_Never, which meant never inserting a space except when after new/delete. Fixes #78892.
1 parent 179ade6 commit d40f2ed

File tree

6 files changed

+56
-121
lines changed

6 files changed

+56
-121
lines changed

‎clang/docs/ClangFormatStyleOptions.rst

Lines changed: 12 additions & 25 deletions
Original file line numberDiff line numberDiff line change
@@ -5276,7 +5276,7 @@ the configuration (without a prefix: ``Auto``).
52765276

52775277
Possible values:
52785278

5279-
* ``SBPO_Never`` (in configuration: ``Never``)
5279+
* ``SBPO_None`` (in configuration: ``None``)
52805280
Never put a space before opening parentheses.
52815281

52825282
.. code-block:: c++
@@ -5287,6 +5287,11 @@ the configuration (without a prefix: ``Auto``).
52875287
}
52885288
}
52895289

5290+
* ``SBPO_Never`` (in configuration: ``Never``)
5291+
This is **deprecated** and replaced by ``Custom`` below, with all
5292+
``SpaceBeforeParensOptions`` but ``AfterPlacementOperator`` set to
5293+
``false``.
5294+
52905295
* ``SBPO_ControlStatements`` (in configuration: ``ControlStatements``)
52915296
Put a space before opening parentheses only after control statement
52925297
keywords (``for/if/while...``).
@@ -5425,32 +5430,14 @@ the configuration (without a prefix: ``Auto``).
54255430
void operator++ (int a); vs. void operator++(int a);
54265431
object.operator++ (10); object.operator++(10);
54275432

5428-
* ``AfterPlacementOperatorStyle AfterPlacementOperator`` :versionbadge:`clang-format 18`
5429-
5430-
Defines in which cases to put a space between ``new/delete`` operators
5431-
and opening parentheses.
5433+
* ``bool AfterPlacementOperator`` If ``true``, put a space between operator ``new``/``delete`` and opening
5434+
parenthesis.
54325435

5433-
Possible values:
5434-
5435-
* ``APO_Never`` (in configuration: ``Never``)
5436-
Remove space after ``new/delete`` operators and before ``(``.
5437-
5438-
.. code-block:: c++
5439-
5440-
new(buf) T;
5441-
delete(buf) T;
5442-
5443-
* ``APO_Always`` (in configuration: ``Always``)
5444-
Always add space after ``new/delete`` operators and before ``(``.
5445-
5446-
.. code-block:: c++
5447-
5448-
new (buf) T;
5449-
delete (buf) T;
5450-
5451-
* ``APO_Leave`` (in configuration: ``Leave``)
5452-
Leave placement ``new/delete`` expressions as they are.
5436+
.. code-block:: c++
54535437

5438+
true: false:
5439+
new (buf) T; vs. new(buf) T;
5440+
delete (buf) T; delete(buf) T;
54545441

54555442
* ``bool AfterRequiresInClause`` If ``true``, put space between requires keyword in a requires clause and
54565443
opening parentheses, if there is one.

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

Lines changed: 13 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -4165,6 +4165,10 @@ struct FormatStyle {
41654165
/// }
41664166
/// }
41674167
/// \endcode
4168+
SBPO_None,
4169+
/// This is **deprecated** and replaced by ``Custom`` below, with all
4170+
/// ``SpaceBeforeParensOptions`` but ``AfterPlacementOperator`` set to
4171+
/// ``false``.
41684172
SBPO_Never,
41694173
/// Put a space before opening parentheses only after control statement
41704174
/// keywords (``for/if/while...``).
@@ -4273,28 +4277,14 @@ struct FormatStyle {
42734277
/// object.operator++ (10); object.operator++(10);
42744278
/// \endcode
42754279
bool AfterOverloadedOperator;
4276-
/// Styles for adding spacing between ``new/delete`` operators and opening
4277-
/// parentheses.
4278-
enum AfterPlacementOperatorStyle : int8_t {
4279-
/// Remove space after ``new/delete`` operators and before ``(``.
4280-
/// \code
4281-
/// new(buf) T;
4282-
/// delete(buf) T;
4283-
/// \endcode
4284-
APO_Never,
4285-
/// Always add space after ``new/delete`` operators and before ``(``.
4286-
/// \code
4287-
/// new (buf) T;
4288-
/// delete (buf) T;
4289-
/// \endcode
4290-
APO_Always,
4291-
/// Leave placement ``new/delete`` expressions as they are.
4292-
APO_Leave,
4293-
};
4294-
/// Defines in which cases to put a space between ``new/delete`` operators
4295-
/// and opening parentheses.
4296-
/// \version 18
4297-
AfterPlacementOperatorStyle AfterPlacementOperator;
4280+
/// If ``true``, put a space between operator ``new``/``delete`` and opening
4281+
/// parenthesis.
4282+
/// \code
4283+
/// true: false:
4284+
/// new (buf) T; vs. new(buf) T;
4285+
/// delete (buf) T; delete(buf) T;
4286+
/// \endcode
4287+
bool AfterPlacementOperator;
42984288
/// If ``true``, put space between requires keyword in a requires clause and
42994289
/// opening parentheses, if there is one.
43004290
/// \code
@@ -4327,7 +4317,7 @@ struct FormatStyle {
43274317
: AfterControlStatements(false), AfterForeachMacros(false),
43284318
AfterFunctionDeclarationName(false),
43294319
AfterFunctionDefinitionName(false), AfterIfMacros(false),
4330-
AfterOverloadedOperator(false), AfterPlacementOperator(APO_Leave),
4320+
AfterOverloadedOperator(false), AfterPlacementOperator(true),
43314321
AfterRequiresInClause(false), AfterRequiresInExpression(false),
43324322
BeforeNonEmptyParentheses(false) {}
43334323

‎clang/lib/Format/Format.cpp

Lines changed: 8 additions & 24 deletions
Original file line numberDiff line numberDiff line change
@@ -504,22 +504,6 @@ struct ScalarEnumerationTraits<FormatStyle::QualifierAlignmentStyle> {
504504
}
505505
};
506506

507-
template <>
508-
struct MappingTraits<
509-
FormatStyle::SpaceBeforeParensCustom::AfterPlacementOperatorStyle> {
510-
static void
511-
mapping(IO &IO,
512-
FormatStyle::SpaceBeforeParensCustom::AfterPlacementOperatorStyle
513-
&Value) {
514-
IO.enumCase(Value, "Always",
515-
FormatStyle::SpaceBeforeParensCustom::APO_Always);
516-
IO.enumCase(Value, "Never",
517-
FormatStyle::SpaceBeforeParensCustom::APO_Never);
518-
IO.enumCase(Value, "Leave",
519-
FormatStyle::SpaceBeforeParensCustom::APO_Leave);
520-
}
521-
};
522-
523507
template <> struct MappingTraits<FormatStyle::RawStringFormat> {
524508
static void mapping(IO &IO, FormatStyle::RawStringFormat &Format) {
525509
IO.mapOptional("Language", Format.Language);
@@ -707,7 +691,8 @@ template <> struct MappingTraits<FormatStyle::SpaceBeforeParensCustom> {
707691
template <>
708692
struct ScalarEnumerationTraits<FormatStyle::SpaceBeforeParensStyle> {
709693
static void enumeration(IO &IO, FormatStyle::SpaceBeforeParensStyle &Value) {
710-
IO.enumCase(Value, "Never", FormatStyle::SBPO_Never);
694+
IO.enumCase(Value, "None", FormatStyle::SBPO_None);
695+
IO.enumCase(Value, "Never", FormatStyle::SBPO_Custom);
711696
IO.enumCase(Value, "ControlStatements",
712697
FormatStyle::SBPO_ControlStatements);
713698
IO.enumCase(Value, "ControlStatementsExceptControlMacros",
@@ -718,7 +703,7 @@ struct ScalarEnumerationTraits<FormatStyle::SpaceBeforeParensStyle> {
718703
IO.enumCase(Value, "Custom", FormatStyle::SBPO_Custom);
719704

720705
// For backward compatibility.
721-
IO.enumCase(Value, "false", FormatStyle::SBPO_Never);
706+
IO.enumCase(Value, "false", FormatStyle::SBPO_Custom);
722707
IO.enumCase(Value, "true", FormatStyle::SBPO_ControlStatements);
723708
IO.enumCase(Value, "ControlStatementsExceptForEachMacros",
724709
FormatStyle::SBPO_ControlStatementsExceptControlMacros);
@@ -1389,11 +1374,12 @@ static void expandPresetsSpaceBeforeParens(FormatStyle &Expanded) {
13891374
// Reset all flags
13901375
Expanded.SpaceBeforeParensOptions = {};
13911376

1377+
if (Expanded.SpaceBeforeParens == FormatStyle::SBPO_None)
1378+
return;
1379+
1380+
Expanded.SpaceBeforeParensOptions.AfterPlacementOperator = true;
1381+
13921382
switch (Expanded.SpaceBeforeParens) {
1393-
case FormatStyle::SBPO_Never:
1394-
Expanded.SpaceBeforeParensOptions.AfterPlacementOperator =
1395-
FormatStyle::SpaceBeforeParensCustom::APO_Never;
1396-
break;
13971383
case FormatStyle::SBPO_ControlStatements:
13981384
Expanded.SpaceBeforeParensOptions.AfterControlStatements = true;
13991385
Expanded.SpaceBeforeParensOptions.AfterForeachMacros = true;
@@ -1405,8 +1391,6 @@ static void expandPresetsSpaceBeforeParens(FormatStyle &Expanded) {
14051391
case FormatStyle::SBPO_NonEmptyParentheses:
14061392
Expanded.SpaceBeforeParensOptions.BeforeNonEmptyParentheses = true;
14071393
break;
1408-
case FormatStyle::SBPO_Always:
1409-
break;
14101394
default:
14111395
break;
14121396
}

‎clang/lib/Format/TokenAnnotator.cpp

Lines changed: 3 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -4274,14 +4274,7 @@ bool TokenAnnotator::spaceRequiredBetween(const AnnotatedLine &Line,
42744274
Left.isOneOf(tok::kw_new, tok::kw_delete) &&
42754275
Right.isNot(TT_OverloadedOperatorLParen) &&
42764276
!(Line.MightBeFunctionDecl && Left.is(TT_FunctionDeclarationName))) {
4277-
if (Style.SpaceBeforeParensOptions.AfterPlacementOperator ==
4278-
FormatStyle::SpaceBeforeParensCustom::APO_Always ||
4279-
(Style.SpaceBeforeParensOptions.AfterPlacementOperator ==
4280-
FormatStyle::SpaceBeforeParensCustom::APO_Leave &&
4281-
Right.hasWhitespaceBefore())) {
4282-
return true;
4283-
}
4284-
return false;
4277+
return Style.SpaceBeforeParensOptions.AfterPlacementOperator;
42854278
}
42864279
if (Line.Type == LT_ObjCDecl)
42874280
return true;
@@ -4322,14 +4315,14 @@ bool TokenAnnotator::spaceRequiredBetween(const AnnotatedLine &Line,
43224315
}
43234316
if (Left.isOneOf(tok::kw_new, tok::kw_delete)) {
43244317
return ((!Line.MightBeFunctionDecl || !Left.Previous) &&
4325-
Style.SpaceBeforeParens != FormatStyle::SBPO_Never) ||
4318+
Style.SpaceBeforeParens > FormatStyle::SBPO_Never) ||
43264319
spaceRequiredBeforeParens(Right);
43274320
}
43284321

43294322
if (Left.is(tok::r_square) && Left.MatchingParen &&
43304323
Left.MatchingParen->Previous &&
43314324
Left.MatchingParen->Previous->is(tok::kw_delete)) {
4332-
return (Style.SpaceBeforeParens != FormatStyle::SBPO_Never) ||
4325+
return (Style.SpaceBeforeParens > FormatStyle::SBPO_Never) ||
43334326
spaceRequiredBeforeParens(Right);
43344327
}
43354328
}

‎clang/unittests/Format/ConfigParseTest.cpp

Lines changed: 6 additions & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -231,6 +231,7 @@ TEST(ConfigParseTest, ParsesConfigurationBools) {
231231
AfterFunctionDefinitionName);
232232
CHECK_PARSE_NESTED_BOOL(SpaceBeforeParensOptions, AfterIfMacros);
233233
CHECK_PARSE_NESTED_BOOL(SpaceBeforeParensOptions, AfterOverloadedOperator);
234+
CHECK_PARSE_NESTED_BOOL(SpaceBeforeParensOptions, AfterPlacementOperator);
234235
CHECK_PARSE_NESTED_BOOL(SpaceBeforeParensOptions, BeforeNonEmptyParentheses);
235236
CHECK_PARSE_NESTED_BOOL(SpacesInParensOptions, InCStyleCasts);
236237
CHECK_PARSE_NESTED_BOOL(SpacesInParensOptions, InConditionalStatements);
@@ -587,8 +588,10 @@ TEST(ConfigParseTest, ParsesConfiguration) {
587588
SpaceAroundPointerQualifiers, FormatStyle::SAPQ_Both);
588589

589590
Style.SpaceBeforeParens = FormatStyle::SBPO_Always;
591+
CHECK_PARSE("SpaceBeforeParens: None", SpaceBeforeParens,
592+
FormatStyle::SBPO_None);
590593
CHECK_PARSE("SpaceBeforeParens: Never", SpaceBeforeParens,
591-
FormatStyle::SBPO_Never);
594+
FormatStyle::SBPO_Custom);
592595
CHECK_PARSE("SpaceBeforeParens: Always", SpaceBeforeParens,
593596
FormatStyle::SBPO_Always);
594597
CHECK_PARSE("SpaceBeforeParens: ControlStatements", SpaceBeforeParens,
@@ -601,32 +604,14 @@ TEST(ConfigParseTest, ParsesConfiguration) {
601604
CHECK_PARSE("SpaceBeforeParens: Custom", SpaceBeforeParens,
602605
FormatStyle::SBPO_Custom);
603606
// For backward compatibility:
604-
CHECK_PARSE("SpaceAfterControlStatementKeyword: false", SpaceBeforeParens,
605-
FormatStyle::SBPO_Never);
606607
CHECK_PARSE("SpaceAfterControlStatementKeyword: true", SpaceBeforeParens,
607608
FormatStyle::SBPO_ControlStatements);
609+
CHECK_PARSE("SpaceAfterControlStatementKeyword: false", SpaceBeforeParens,
610+
FormatStyle::SBPO_Custom);
608611
CHECK_PARSE("SpaceBeforeParens: ControlStatementsExceptForEachMacros",
609612
SpaceBeforeParens,
610613
FormatStyle::SBPO_ControlStatementsExceptControlMacros);
611614

612-
Style.SpaceBeforeParens = FormatStyle::SBPO_Custom;
613-
Style.SpaceBeforeParensOptions.AfterPlacementOperator =
614-
FormatStyle::SpaceBeforeParensCustom::APO_Always;
615-
CHECK_PARSE("SpaceBeforeParensOptions:\n"
616-
" AfterPlacementOperator: Never",
617-
SpaceBeforeParensOptions.AfterPlacementOperator,
618-
FormatStyle::SpaceBeforeParensCustom::APO_Never);
619-
620-
CHECK_PARSE("SpaceBeforeParensOptions:\n"
621-
" AfterPlacementOperator: Always",
622-
SpaceBeforeParensOptions.AfterPlacementOperator,
623-
FormatStyle::SpaceBeforeParensCustom::APO_Always);
624-
625-
CHECK_PARSE("SpaceBeforeParensOptions:\n"
626-
" AfterPlacementOperator: Leave",
627-
SpaceBeforeParensOptions.AfterPlacementOperator,
628-
FormatStyle::SpaceBeforeParensCustom::APO_Leave);
629-
630615
// For backward compatibility:
631616
Style.SpacesInParens = FormatStyle::SIPO_Never;
632617
Style.SpacesInParensOptions = {};

‎clang/unittests/Format/FormatTest.cpp

Lines changed: 14 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -11347,35 +11347,31 @@ TEST_F(FormatTest, UnderstandsNewAndDelete) {
1134711347

1134811348
FormatStyle AfterPlacementOperator = getLLVMStyle();
1134911349
AfterPlacementOperator.SpaceBeforeParens = FormatStyle::SBPO_Custom;
11350-
EXPECT_EQ(
11351-
AfterPlacementOperator.SpaceBeforeParensOptions.AfterPlacementOperator,
11352-
FormatStyle::SpaceBeforeParensCustom::APO_Leave);
11350+
EXPECT_TRUE(
11351+
AfterPlacementOperator.SpaceBeforeParensOptions.AfterPlacementOperator);
1135311352
verifyFormat("new (buf) int;", AfterPlacementOperator);
11354-
verifyFormat("new(buf) int;", AfterPlacementOperator);
11355-
11356-
AfterPlacementOperator.SpaceBeforeParensOptions.AfterPlacementOperator =
11357-
FormatStyle::SpaceBeforeParensCustom::APO_Never;
1135811353
verifyFormat("struct A {\n"
1135911354
" int *a;\n"
11360-
" A(int *p) : a(new(p) int) {\n"
11361-
" new(p) int;\n"
11362-
" int *b = new(p) int;\n"
11363-
" int *c = new(p) int(3);\n"
11364-
" delete(b);\n"
11355+
" A(int *p) : a(new (p) int) {\n"
11356+
" new (p) int;\n"
11357+
" int *b = new (p) int;\n"
11358+
" int *c = new (p) int(3);\n"
11359+
" delete (b);\n"
1136511360
" }\n"
1136611361
"};",
1136711362
AfterPlacementOperator);
1136811363
verifyFormat("void operator new(void *foo) ATTRIB;", AfterPlacementOperator);
1136911364

1137011365
AfterPlacementOperator.SpaceBeforeParensOptions.AfterPlacementOperator =
11371-
FormatStyle::SpaceBeforeParensCustom::APO_Always;
11366+
false;
11367+
verifyFormat("new(buf) int;", AfterPlacementOperator);
1137211368
verifyFormat("struct A {\n"
1137311369
" int *a;\n"
11374-
" A(int *p) : a(new (p) int) {\n"
11375-
" new (p) int;\n"
11376-
" int *b = new (p) int;\n"
11377-
" int *c = new (p) int(3);\n"
11378-
" delete (b);\n"
11370+
" A(int *p) : a(new(p) int) {\n"
11371+
" new(p) int;\n"
11372+
" int *b = new(p) int;\n"
11373+
" int *c = new(p) int(3);\n"
11374+
" delete(b);\n"
1137911375
" }\n"
1138011376
"};",
1138111377
AfterPlacementOperator);

0 commit comments

Comments
 (0)