Skip to content

Commit f0bd62d

Browse files
bradh352bradh352
authored
[clang-format] Add AlignFunctionDeclarations to AlignConsecutiveDeclarations (#108241)
Enabling AlignConsecutiveDeclarations also aligns function prototypes or declarations. This is often unexpected as typically function prototypes, especially in public headers, don't use any padding. Setting AlignFunctionDeclarations to false will skip this alignment. It is by default set to true to keep compatibility with prior versions to not make unexpected changes. Fixes #74320
1 parent c4d8920 commit f0bd62d

File tree

7 files changed

+166
-30
lines changed

7 files changed

+166
-30
lines changed

‎clang/docs/ClangFormatStyleOptions.rst

+105
Original file line numberDiff line numberDiff line change
@@ -392,6 +392,21 @@ the configuration (without a prefix: ``Auto``).
392392
a &= 2;
393393
bbb = 2;
394394

395+
* ``bool AlignFunctionDeclarations`` Only for ``AlignConsecutiveDeclarations``. Whether function declarations
396+
are aligned.
397+
398+
.. code-block:: c++
399+
400+
true:
401+
unsigned int f1(void);
402+
void f2(void);
403+
size_t f3(void);
404+
405+
false:
406+
unsigned int f1(void);
407+
void f2(void);
408+
size_t f3(void);
409+
395410
* ``bool AlignFunctionPointers`` Only for ``AlignConsecutiveDeclarations``. Whether function pointers are
396411
aligned.
397412

@@ -534,6 +549,21 @@ the configuration (without a prefix: ``Auto``).
534549
a &= 2;
535550
bbb = 2;
536551

552+
* ``bool AlignFunctionDeclarations`` Only for ``AlignConsecutiveDeclarations``. Whether function declarations
553+
are aligned.
554+
555+
.. code-block:: c++
556+
557+
true:
558+
unsigned int f1(void);
559+
void f2(void);
560+
size_t f3(void);
561+
562+
false:
563+
unsigned int f1(void);
564+
void f2(void);
565+
size_t f3(void);
566+
537567
* ``bool AlignFunctionPointers`` Only for ``AlignConsecutiveDeclarations``. Whether function pointers are
538568
aligned.
539569

@@ -676,6 +706,21 @@ the configuration (without a prefix: ``Auto``).
676706
a &= 2;
677707
bbb = 2;
678708

709+
* ``bool AlignFunctionDeclarations`` Only for ``AlignConsecutiveDeclarations``. Whether function declarations
710+
are aligned.
711+
712+
.. code-block:: c++
713+
714+
true:
715+
unsigned int f1(void);
716+
void f2(void);
717+
size_t f3(void);
718+
719+
false:
720+
unsigned int f1(void);
721+
void f2(void);
722+
size_t f3(void);
723+
679724
* ``bool AlignFunctionPointers`` Only for ``AlignConsecutiveDeclarations``. Whether function pointers are
680725
aligned.
681726

@@ -819,6 +864,21 @@ the configuration (without a prefix: ``Auto``).
819864
a &= 2;
820865
bbb = 2;
821866

867+
* ``bool AlignFunctionDeclarations`` Only for ``AlignConsecutiveDeclarations``. Whether function declarations
868+
are aligned.
869+
870+
.. code-block:: c++
871+
872+
true:
873+
unsigned int f1(void);
874+
void f2(void);
875+
size_t f3(void);
876+
877+
false:
878+
unsigned int f1(void);
879+
void f2(void);
880+
size_t f3(void);
881+
822882
* ``bool AlignFunctionPointers`` Only for ``AlignConsecutiveDeclarations``. Whether function pointers are
823883
aligned.
824884

@@ -1081,6 +1141,21 @@ the configuration (without a prefix: ``Auto``).
10811141
a &= 2;
10821142
bbb = 2;
10831143

1144+
* ``bool AlignFunctionDeclarations`` Only for ``AlignConsecutiveDeclarations``. Whether function declarations
1145+
are aligned.
1146+
1147+
.. code-block:: c++
1148+
1149+
true:
1150+
unsigned int f1(void);
1151+
void f2(void);
1152+
size_t f3(void);
1153+
1154+
false:
1155+
unsigned int f1(void);
1156+
void f2(void);
1157+
size_t f3(void);
1158+
10841159
* ``bool AlignFunctionPointers`` Only for ``AlignConsecutiveDeclarations``. Whether function pointers are
10851160
aligned.
10861161

@@ -1221,6 +1296,21 @@ the configuration (without a prefix: ``Auto``).
12211296
a &= 2;
12221297
bbb = 2;
12231298

1299+
* ``bool AlignFunctionDeclarations`` Only for ``AlignConsecutiveDeclarations``. Whether function declarations
1300+
are aligned.
1301+
1302+
.. code-block:: c++
1303+
1304+
true:
1305+
unsigned int f1(void);
1306+
void f2(void);
1307+
size_t f3(void);
1308+
1309+
false:
1310+
unsigned int f1(void);
1311+
void f2(void);
1312+
size_t f3(void);
1313+
12241314
* ``bool AlignFunctionPointers`` Only for ``AlignConsecutiveDeclarations``. Whether function pointers are
12251315
aligned.
12261316

@@ -1361,6 +1451,21 @@ the configuration (without a prefix: ``Auto``).
13611451
a &= 2;
13621452
bbb = 2;
13631453

1454+
* ``bool AlignFunctionDeclarations`` Only for ``AlignConsecutiveDeclarations``. Whether function declarations
1455+
are aligned.
1456+
1457+
.. code-block:: c++
1458+
1459+
true:
1460+
unsigned int f1(void);
1461+
void f2(void);
1462+
size_t f3(void);
1463+
1464+
false:
1465+
unsigned int f1(void);
1466+
void f2(void);
1467+
size_t f3(void);
1468+
13641469
* ``bool AlignFunctionPointers`` Only for ``AlignConsecutiveDeclarations``. Whether function pointers are
13651470
aligned.
13661471

‎clang/docs/ReleaseNotes.rst

+1
Original file line numberDiff line numberDiff line change
@@ -616,6 +616,7 @@ clang-format
616616

617617
- Adds ``BreakBinaryOperations`` option.
618618
- Adds ``TemplateNames`` option.
619+
- Adds ``AlignFunctionDeclarations`` option to ``AlignConsecutiveDeclarations``.
619620

620621
libclang
621622
--------

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

+15
Original file line numberDiff line numberDiff line change
@@ -225,6 +225,20 @@ struct FormatStyle {
225225
/// bbb = 2;
226226
/// \endcode
227227
bool AlignCompound;
228+
/// Only for ``AlignConsecutiveDeclarations``. Whether function declarations
229+
/// are aligned.
230+
/// \code
231+
/// true:
232+
/// unsigned int f1(void);
233+
/// void f2(void);
234+
/// size_t f3(void);
235+
///
236+
/// false:
237+
/// unsigned int f1(void);
238+
/// void f2(void);
239+
/// size_t f3(void);
240+
/// \endcode
241+
bool AlignFunctionDeclarations;
228242
/// Only for ``AlignConsecutiveDeclarations``. Whether function pointers are
229243
/// aligned.
230244
/// \code
@@ -264,6 +278,7 @@ struct FormatStyle {
264278
return Enabled == R.Enabled && AcrossEmptyLines == R.AcrossEmptyLines &&
265279
AcrossComments == R.AcrossComments &&
266280
AlignCompound == R.AlignCompound &&
281+
AlignFunctionDeclarations == R.AlignFunctionDeclarations &&
267282
AlignFunctionPointers == R.AlignFunctionPointers &&
268283
PadOperators == R.PadOperators;
269284
}

‎clang/lib/Format/Format.cpp

+20-15
Original file line numberDiff line numberDiff line change
@@ -44,50 +44,54 @@ struct ScalarEnumerationTraits<FormatStyle::BreakBeforeNoexceptSpecifierStyle> {
4444

4545
template <> struct MappingTraits<FormatStyle::AlignConsecutiveStyle> {
4646
static void enumInput(IO &IO, FormatStyle::AlignConsecutiveStyle &Value) {
47-
IO.enumCase(Value, "None",
48-
FormatStyle::AlignConsecutiveStyle(
49-
{/*Enabled=*/false, /*AcrossEmptyLines=*/false,
50-
/*AcrossComments=*/false, /*AlignCompound=*/false,
51-
/*AlignFunctionPointers=*/false, /*PadOperators=*/true}));
47+
IO.enumCase(Value, "None", FormatStyle::AlignConsecutiveStyle({}));
5248
IO.enumCase(Value, "Consecutive",
5349
FormatStyle::AlignConsecutiveStyle(
5450
{/*Enabled=*/true, /*AcrossEmptyLines=*/false,
5551
/*AcrossComments=*/false, /*AlignCompound=*/false,
56-
/*AlignFunctionPointers=*/false, /*PadOperators=*/true}));
52+
/*AlignFunctionDeclarations=*/true,
53+
/*AlignFunctionPointers=*/false,
54+
/*PadOperators=*/true}));
5755
IO.enumCase(Value, "AcrossEmptyLines",
5856
FormatStyle::AlignConsecutiveStyle(
5957
{/*Enabled=*/true, /*AcrossEmptyLines=*/true,
6058
/*AcrossComments=*/false, /*AlignCompound=*/false,
61-
/*AlignFunctionPointers=*/false, /*PadOperators=*/true}));
59+
/*AlignFunctionDeclarations=*/true,
60+
/*AlignFunctionPointers=*/false,
61+
/*PadOperators=*/true}));
6262
IO.enumCase(Value, "AcrossComments",
6363
FormatStyle::AlignConsecutiveStyle(
6464
{/*Enabled=*/true, /*AcrossEmptyLines=*/false,
6565
/*AcrossComments=*/true, /*AlignCompound=*/false,
66-
/*AlignFunctionPointers=*/false, /*PadOperators=*/true}));
66+
/*AlignFunctionDeclarations=*/true,
67+
/*AlignFunctionPointers=*/false,
68+
/*PadOperators=*/true}));
6769
IO.enumCase(Value, "AcrossEmptyLinesAndComments",
6870
FormatStyle::AlignConsecutiveStyle(
6971
{/*Enabled=*/true, /*AcrossEmptyLines=*/true,
7072
/*AcrossComments=*/true, /*AlignCompound=*/false,
71-
/*AlignFunctionPointers=*/false, /*PadOperators=*/true}));
73+
/*AlignFunctionDeclarations=*/true,
74+
/*AlignFunctionPointers=*/false,
75+
/*PadOperators=*/true}));
7276

7377
// For backward compatibility.
7478
IO.enumCase(Value, "true",
7579
FormatStyle::AlignConsecutiveStyle(
7680
{/*Enabled=*/true, /*AcrossEmptyLines=*/false,
7781
/*AcrossComments=*/false, /*AlignCompound=*/false,
78-
/*AlignFunctionPointers=*/false, /*PadOperators=*/true}));
79-
IO.enumCase(Value, "false",
80-
FormatStyle::AlignConsecutiveStyle(
81-
{/*Enabled=*/false, /*AcrossEmptyLines=*/false,
82-
/*AcrossComments=*/false, /*AlignCompound=*/false,
83-
/*AlignFunctionPointers=*/false, /*PadOperators=*/true}));
82+
/*AlignFunctionDeclarations=*/true,
83+
/*AlignFunctionPointers=*/false,
84+
/*PadOperators=*/true}));
85+
IO.enumCase(Value, "false", FormatStyle::AlignConsecutiveStyle({}));
8486
}
8587

8688
static void mapping(IO &IO, FormatStyle::AlignConsecutiveStyle &Value) {
8789
IO.mapOptional("Enabled", Value.Enabled);
8890
IO.mapOptional("AcrossEmptyLines", Value.AcrossEmptyLines);
8991
IO.mapOptional("AcrossComments", Value.AcrossComments);
9092
IO.mapOptional("AlignCompound", Value.AlignCompound);
93+
IO.mapOptional("AlignFunctionDeclarations",
94+
Value.AlignFunctionDeclarations);
9195
IO.mapOptional("AlignFunctionPointers", Value.AlignFunctionPointers);
9296
IO.mapOptional("PadOperators", Value.PadOperators);
9397
}
@@ -1449,6 +1453,7 @@ FormatStyle getLLVMStyle(FormatStyle::LanguageKind Language) {
14491453
LLVMStyle.AlignConsecutiveAssignments.PadOperators = true;
14501454
LLVMStyle.AlignConsecutiveBitFields = {};
14511455
LLVMStyle.AlignConsecutiveDeclarations = {};
1456+
LLVMStyle.AlignConsecutiveDeclarations.AlignFunctionDeclarations = true;
14521457
LLVMStyle.AlignConsecutiveMacros = {};
14531458
LLVMStyle.AlignConsecutiveShortCaseStatements = {};
14541459
LLVMStyle.AlignConsecutiveTableGenBreakingDAGArgColons = {};

‎clang/lib/Format/WhitespaceManager.cpp

+1-1
Original file line numberDiff line numberDiff line change
@@ -1020,7 +1020,7 @@ void WhitespaceManager::alignConsecutiveDeclarations() {
10201020
return true;
10211021
}
10221022
if (C.Tok->is(TT_FunctionDeclarationName))
1023-
return true;
1023+
return Style.AlignConsecutiveDeclarations.AlignFunctionDeclarations;
10241024
if (C.Tok->isNot(TT_StartOfName))
10251025
return false;
10261026
if (C.Tok->Previous &&

‎clang/unittests/Format/ConfigParseTest.cpp

+9-12
Original file line numberDiff line numberDiff line change
@@ -300,48 +300,45 @@ TEST(ConfigParseTest, ParsesConfiguration) {
300300
#define CHECK_ALIGN_CONSECUTIVE(FIELD) \
301301
do { \
302302
Style.FIELD.Enabled = true; \
303-
CHECK_PARSE( \
304-
#FIELD ": None", FIELD, \
305-
FormatStyle::AlignConsecutiveStyle( \
306-
{/*Enabled=*/false, /*AcrossEmptyLines=*/false, \
307-
/*AcrossComments=*/false, /*AlignCompound=*/false, \
308-
/*AlignFunctionPointers=*/false, /*PadOperators=*/true})); \
303+
CHECK_PARSE(#FIELD ": None", FIELD, \
304+
FormatStyle::AlignConsecutiveStyle({})); \
309305
CHECK_PARSE( \
310306
#FIELD ": Consecutive", FIELD, \
311307
FormatStyle::AlignConsecutiveStyle( \
312308
{/*Enabled=*/true, /*AcrossEmptyLines=*/false, \
313309
/*AcrossComments=*/false, /*AlignCompound=*/false, \
310+
/*AlignFunctionDeclarations=*/true, \
314311
/*AlignFunctionPointers=*/false, /*PadOperators=*/true})); \
315312
CHECK_PARSE( \
316313
#FIELD ": AcrossEmptyLines", FIELD, \
317314
FormatStyle::AlignConsecutiveStyle( \
318315
{/*Enabled=*/true, /*AcrossEmptyLines=*/true, \
319316
/*AcrossComments=*/false, /*AlignCompound=*/false, \
317+
/*AlignFunctionDeclarations=*/true, \
320318
/*AlignFunctionPointers=*/false, /*PadOperators=*/true})); \
321319
CHECK_PARSE( \
322320
#FIELD ": AcrossEmptyLinesAndComments", FIELD, \
323321
FormatStyle::AlignConsecutiveStyle( \
324322
{/*Enabled=*/true, /*AcrossEmptyLines=*/true, \
325323
/*AcrossComments=*/true, /*AlignCompound=*/false, \
324+
/*AlignFunctionDeclarations=*/true, \
326325
/*AlignFunctionPointers=*/false, /*PadOperators=*/true})); \
327326
/* For backwards compability, false / true should still parse */ \
328-
CHECK_PARSE( \
329-
#FIELD ": false", FIELD, \
330-
FormatStyle::AlignConsecutiveStyle( \
331-
{/*Enabled=*/false, /*AcrossEmptyLines=*/false, \
332-
/*AcrossComments=*/false, /*AlignCompound=*/false, \
333-
/*AlignFunctionPointers=*/false, /*PadOperators=*/true})); \
327+
CHECK_PARSE(#FIELD ": false", FIELD, \
328+
FormatStyle::AlignConsecutiveStyle({})); \
334329
CHECK_PARSE( \
335330
#FIELD ": true", FIELD, \
336331
FormatStyle::AlignConsecutiveStyle( \
337332
{/*Enabled=*/true, /*AcrossEmptyLines=*/false, \
338333
/*AcrossComments=*/false, /*AlignCompound=*/false, \
334+
/*AlignFunctionDeclarations=*/true, \
339335
/*AlignFunctionPointers=*/false, /*PadOperators=*/true})); \
340336
\
341337
CHECK_PARSE_NESTED_BOOL(FIELD, Enabled); \
342338
CHECK_PARSE_NESTED_BOOL(FIELD, AcrossEmptyLines); \
343339
CHECK_PARSE_NESTED_BOOL(FIELD, AcrossComments); \
344340
CHECK_PARSE_NESTED_BOOL(FIELD, AlignCompound); \
341+
CHECK_PARSE_NESTED_BOOL(FIELD, AlignFunctionDeclarations); \
345342
CHECK_PARSE_NESTED_BOOL(FIELD, PadOperators); \
346343
} while (false)
347344

‎clang/unittests/Format/FormatTest.cpp

+15-2
Original file line numberDiff line numberDiff line change
@@ -20021,6 +20021,12 @@ TEST_F(FormatTest, AlignConsecutiveDeclarations) {
2002120021
" return 0;\n"
2002220022
"}() };",
2002320023
BracedAlign);
20024+
20025+
Alignment.AlignConsecutiveDeclarations.AlignFunctionDeclarations = false;
20026+
verifyFormat("unsigned int f1(void);\n"
20027+
"void f2(void);\n"
20028+
"size_t f3(void);",
20029+
Alignment);
2002420030
}
2002520031

2002620032
TEST_F(FormatTest, AlignConsecutiveShortCaseStatements) {
@@ -20264,9 +20270,16 @@ TEST_F(FormatTest, AlignWithLineBreaks) {
2026420270
FormatStyle::AlignConsecutiveStyle(
2026520271
{/*Enabled=*/false, /*AcrossEmptyLines=*/false,
2026620272
/*AcrossComments=*/false, /*AlignCompound=*/false,
20267-
/*AlignFunctionPointers=*/false, /*PadOperators=*/true}));
20273+
/*AlignFunctionDeclarations=*/false,
20274+
/*AlignFunctionPointers=*/false,
20275+
/*PadOperators=*/true}));
2026820276
EXPECT_EQ(Style.AlignConsecutiveDeclarations,
20269-
FormatStyle::AlignConsecutiveStyle({}));
20277+
FormatStyle::AlignConsecutiveStyle(
20278+
{/*Enabled=*/false, /*AcrossEmptyLines=*/false,
20279+
/*AcrossComments=*/false, /*AlignCompound=*/false,
20280+
/*AlignFunctionDeclarations=*/true,
20281+
/*AlignFunctionPointers=*/false,
20282+
/*PadOperators=*/false}));
2027020283
verifyFormat("void foo() {\n"
2027120284
" int myVar = 5;\n"
2027220285
" double x = 3.14;\n"

0 commit comments

Comments
 (0)