Skip to content

Commit 00cbf31

Browse files
bradh352bradh352
committed
Add AlignFunctionDeclarations attribute to AlignConsecutiveDeclarations
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. Signed-off-by: Brad House <[email protected]>
1 parent ba4bcce commit 00cbf31

File tree

6 files changed

+179
-10
lines changed

6 files changed

+179
-10
lines changed

‎clang/docs/ClangFormatStyleOptions.rst

Lines changed: 112 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -392,6 +392,22 @@ the configuration (without a prefix: ``Auto``).
392392
a &= 2;
393393
bbb = 2;
394394

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

@@ -534,6 +550,22 @@ the configuration (without a prefix: ``Auto``).
534550
a &= 2;
535551
bbb = 2;
536552

553+
* ``bool AlignFunctionDeclarations`` :versionbadge:`clang-format 20`
554+
Only for ``AlignConsecutiveDeclarations``. Whether function declarations
555+
are aligned.
556+
557+
.. code-block:: c++
558+
559+
true:
560+
unsigned int f1(void);
561+
void f2(void);
562+
size_t f3(void);
563+
564+
false:
565+
unsigned int f1(void);
566+
void f2(void);
567+
size_t f3(void);
568+
537569
* ``bool AlignFunctionPointers`` Only for ``AlignConsecutiveDeclarations``. Whether function pointers are
538570
aligned.
539571

@@ -676,6 +708,22 @@ the configuration (without a prefix: ``Auto``).
676708
a &= 2;
677709
bbb = 2;
678710

711+
* ``bool AlignFunctionDeclarations`` :versionbadge:`clang-format 20`
712+
Only for ``AlignConsecutiveDeclarations``. Whether function declarations
713+
are aligned.
714+
715+
.. code-block:: c++
716+
717+
true:
718+
unsigned int f1(void);
719+
void f2(void);
720+
size_t f3(void);
721+
722+
false:
723+
unsigned int f1(void);
724+
void f2(void);
725+
size_t f3(void);
726+
679727
* ``bool AlignFunctionPointers`` Only for ``AlignConsecutiveDeclarations``. Whether function pointers are
680728
aligned.
681729

@@ -819,6 +867,22 @@ the configuration (without a prefix: ``Auto``).
819867
a &= 2;
820868
bbb = 2;
821869

870+
* ``bool AlignFunctionDeclarations`` :versionbadge:`clang-format 20`
871+
Only for ``AlignConsecutiveDeclarations``. Whether function declarations
872+
are aligned.
873+
874+
.. code-block:: c++
875+
876+
true:
877+
unsigned int f1(void);
878+
void f2(void);
879+
size_t f3(void);
880+
881+
false:
882+
unsigned int f1(void);
883+
void f2(void);
884+
size_t f3(void);
885+
822886
* ``bool AlignFunctionPointers`` Only for ``AlignConsecutiveDeclarations``. Whether function pointers are
823887
aligned.
824888

@@ -1081,6 +1145,22 @@ the configuration (without a prefix: ``Auto``).
10811145
a &= 2;
10821146
bbb = 2;
10831147

1148+
* ``bool AlignFunctionDeclarations`` :versionbadge:`clang-format 20`
1149+
Only for ``AlignConsecutiveDeclarations``. Whether function declarations
1150+
are aligned.
1151+
1152+
.. code-block:: c++
1153+
1154+
true:
1155+
unsigned int f1(void);
1156+
void f2(void);
1157+
size_t f3(void);
1158+
1159+
false:
1160+
unsigned int f1(void);
1161+
void f2(void);
1162+
size_t f3(void);
1163+
10841164
* ``bool AlignFunctionPointers`` Only for ``AlignConsecutiveDeclarations``. Whether function pointers are
10851165
aligned.
10861166

@@ -1221,6 +1301,22 @@ the configuration (without a prefix: ``Auto``).
12211301
a &= 2;
12221302
bbb = 2;
12231303

1304+
* ``bool AlignFunctionDeclarations`` :versionbadge:`clang-format 20`
1305+
Only for ``AlignConsecutiveDeclarations``. Whether function declarations
1306+
are aligned.
1307+
1308+
.. code-block:: c++
1309+
1310+
true:
1311+
unsigned int f1(void);
1312+
void f2(void);
1313+
size_t f3(void);
1314+
1315+
false:
1316+
unsigned int f1(void);
1317+
void f2(void);
1318+
size_t f3(void);
1319+
12241320
* ``bool AlignFunctionPointers`` Only for ``AlignConsecutiveDeclarations``. Whether function pointers are
12251321
aligned.
12261322

@@ -1361,6 +1457,22 @@ the configuration (without a prefix: ``Auto``).
13611457
a &= 2;
13621458
bbb = 2;
13631459

1460+
* ``bool AlignFunctionDeclarations`` :versionbadge:`clang-format 20`
1461+
Only for ``AlignConsecutiveDeclarations``. Whether function declarations
1462+
are aligned.
1463+
1464+
.. code-block:: c++
1465+
1466+
true:
1467+
unsigned int f1(void);
1468+
void f2(void);
1469+
size_t f3(void);
1470+
1471+
false:
1472+
unsigned int f1(void);
1473+
void f2(void);
1474+
size_t f3(void);
1475+
13641476
* ``bool AlignFunctionPointers`` Only for ``AlignConsecutiveDeclarations``. Whether function pointers are
13651477
aligned.
13661478

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

Lines changed: 16 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -225,6 +225,21 @@ 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+
/// \version 20
242+
bool AlignFunctionDeclarations;
228243
/// Only for ``AlignConsecutiveDeclarations``. Whether function pointers are
229244
/// aligned.
230245
/// \code
@@ -264,6 +279,7 @@ struct FormatStyle {
264279
return Enabled == R.Enabled && AcrossEmptyLines == R.AcrossEmptyLines &&
265280
AcrossComments == R.AcrossComments &&
266281
AlignCompound == R.AlignCompound &&
282+
AlignFunctionDeclarations == R.AlignFunctionDeclarations &&
267283
AlignFunctionPointers == R.AlignFunctionPointers &&
268284
PadOperators == R.PadOperators;
269285
}

‎clang/lib/Format/Format.cpp

Lines changed: 24 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -48,46 +48,62 @@ template <> struct MappingTraits<FormatStyle::AlignConsecutiveStyle> {
4848
FormatStyle::AlignConsecutiveStyle(
4949
{/*Enabled=*/false, /*AcrossEmptyLines=*/false,
5050
/*AcrossComments=*/false, /*AlignCompound=*/false,
51-
/*AlignFunctionPointers=*/false, /*PadOperators=*/true}));
51+
/*AlignFunctionDeclarations=*/true,
52+
/*AlignFunctionPointers=*/false,
53+
/*PadOperators=*/true}));
5254
IO.enumCase(Value, "Consecutive",
5355
FormatStyle::AlignConsecutiveStyle(
5456
{/*Enabled=*/true, /*AcrossEmptyLines=*/false,
5557
/*AcrossComments=*/false, /*AlignCompound=*/false,
56-
/*AlignFunctionPointers=*/false, /*PadOperators=*/true}));
58+
/*AlignFunctionDeclarations=*/true,
59+
/*AlignFunctionPointers=*/false,
60+
/*PadOperators=*/true}));
5761
IO.enumCase(Value, "AcrossEmptyLines",
5862
FormatStyle::AlignConsecutiveStyle(
5963
{/*Enabled=*/true, /*AcrossEmptyLines=*/true,
6064
/*AcrossComments=*/false, /*AlignCompound=*/false,
61-
/*AlignFunctionPointers=*/false, /*PadOperators=*/true}));
65+
/*AlignFunctionDeclarations=*/true,
66+
/*AlignFunctionPointers=*/false,
67+
/*PadOperators=*/true}));
6268
IO.enumCase(Value, "AcrossComments",
6369
FormatStyle::AlignConsecutiveStyle(
6470
{/*Enabled=*/true, /*AcrossEmptyLines=*/false,
6571
/*AcrossComments=*/true, /*AlignCompound=*/false,
66-
/*AlignFunctionPointers=*/false, /*PadOperators=*/true}));
72+
/*AlignFunctionDeclarations=*/true,
73+
/*AlignFunctionPointers=*/false,
74+
/*PadOperators=*/true}));
6775
IO.enumCase(Value, "AcrossEmptyLinesAndComments",
6876
FormatStyle::AlignConsecutiveStyle(
6977
{/*Enabled=*/true, /*AcrossEmptyLines=*/true,
7078
/*AcrossComments=*/true, /*AlignCompound=*/false,
71-
/*AlignFunctionPointers=*/false, /*PadOperators=*/true}));
79+
/*AlignFunctionDeclarations=*/true,
80+
/*AlignFunctionPointers=*/false,
81+
/*PadOperators=*/true}));
7282

7383
// For backward compatibility.
7484
IO.enumCase(Value, "true",
7585
FormatStyle::AlignConsecutiveStyle(
7686
{/*Enabled=*/true, /*AcrossEmptyLines=*/false,
7787
/*AcrossComments=*/false, /*AlignCompound=*/false,
78-
/*AlignFunctionPointers=*/false, /*PadOperators=*/true}));
88+
/*AlignFunctionDeclarations=*/true,
89+
/*AlignFunctionPointers=*/false,
90+
/*PadOperators=*/true}));
7991
IO.enumCase(Value, "false",
8092
FormatStyle::AlignConsecutiveStyle(
8193
{/*Enabled=*/false, /*AcrossEmptyLines=*/false,
8294
/*AcrossComments=*/false, /*AlignCompound=*/false,
83-
/*AlignFunctionPointers=*/false, /*PadOperators=*/true}));
95+
/*AlignFunctionDeclarations=*/true,
96+
/*AlignFunctionPointers=*/false,
97+
/*PadOperators=*/true}));
8498
}
8599

86100
static void mapping(IO &IO, FormatStyle::AlignConsecutiveStyle &Value) {
87101
IO.mapOptional("Enabled", Value.Enabled);
88102
IO.mapOptional("AcrossEmptyLines", Value.AcrossEmptyLines);
89103
IO.mapOptional("AcrossComments", Value.AcrossComments);
90104
IO.mapOptional("AlignCompound", Value.AlignCompound);
105+
IO.mapOptional("AlignFunctionDeclarations",
106+
Value.AlignFunctionDeclarations);
91107
IO.mapOptional("AlignFunctionPointers", Value.AlignFunctionPointers);
92108
IO.mapOptional("PadOperators", Value.PadOperators);
93109
}
@@ -1448,6 +1464,7 @@ FormatStyle getLLVMStyle(FormatStyle::LanguageKind Language) {
14481464
LLVMStyle.AlignConsecutiveAssignments.PadOperators = true;
14491465
LLVMStyle.AlignConsecutiveBitFields = {};
14501466
LLVMStyle.AlignConsecutiveDeclarations = {};
1467+
LLVMStyle.AlignConsecutiveDeclarations.AlignFunctionDeclarations = true;
14511468
LLVMStyle.AlignConsecutiveMacros = {};
14521469
LLVMStyle.AlignConsecutiveShortCaseStatements = {};
14531470
LLVMStyle.AlignConsecutiveTableGenBreakingDAGArgColons = {};

‎clang/lib/Format/WhitespaceManager.cpp

Lines changed: 1 addition & 1 deletion
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

Lines changed: 6 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -305,37 +305,43 @@ TEST(ConfigParseTest, ParsesConfiguration) {
305305
FormatStyle::AlignConsecutiveStyle( \
306306
{/*Enabled=*/false, /*AcrossEmptyLines=*/false, \
307307
/*AcrossComments=*/false, /*AlignCompound=*/false, \
308+
/*AlignFunctionDeclarations=*/true, \
308309
/*AlignFunctionPointers=*/false, /*PadOperators=*/true})); \
309310
CHECK_PARSE( \
310311
#FIELD ": Consecutive", FIELD, \
311312
FormatStyle::AlignConsecutiveStyle( \
312313
{/*Enabled=*/true, /*AcrossEmptyLines=*/false, \
313314
/*AcrossComments=*/false, /*AlignCompound=*/false, \
315+
/*AlignFunctionDeclarations=*/true, \
314316
/*AlignFunctionPointers=*/false, /*PadOperators=*/true})); \
315317
CHECK_PARSE( \
316318
#FIELD ": AcrossEmptyLines", FIELD, \
317319
FormatStyle::AlignConsecutiveStyle( \
318320
{/*Enabled=*/true, /*AcrossEmptyLines=*/true, \
319321
/*AcrossComments=*/false, /*AlignCompound=*/false, \
322+
/*AlignFunctionDeclarations=*/true, \
320323
/*AlignFunctionPointers=*/false, /*PadOperators=*/true})); \
321324
CHECK_PARSE( \
322325
#FIELD ": AcrossEmptyLinesAndComments", FIELD, \
323326
FormatStyle::AlignConsecutiveStyle( \
324327
{/*Enabled=*/true, /*AcrossEmptyLines=*/true, \
325328
/*AcrossComments=*/true, /*AlignCompound=*/false, \
329+
/*AlignFunctionDeclarations=*/true, \
326330
/*AlignFunctionPointers=*/false, /*PadOperators=*/true})); \
327331
/* For backwards compability, false / true should still parse */ \
328332
CHECK_PARSE( \
329333
#FIELD ": false", FIELD, \
330334
FormatStyle::AlignConsecutiveStyle( \
331335
{/*Enabled=*/false, /*AcrossEmptyLines=*/false, \
332336
/*AcrossComments=*/false, /*AlignCompound=*/false, \
337+
/*AlignFunctionDeclarations=*/true, \
333338
/*AlignFunctionPointers=*/false, /*PadOperators=*/true})); \
334339
CHECK_PARSE( \
335340
#FIELD ": true", FIELD, \
336341
FormatStyle::AlignConsecutiveStyle( \
337342
{/*Enabled=*/true, /*AcrossEmptyLines=*/false, \
338343
/*AcrossComments=*/false, /*AlignCompound=*/false, \
344+
/*AlignFunctionDeclarations=*/true, \
339345
/*AlignFunctionPointers=*/false, /*PadOperators=*/true})); \
340346
\
341347
CHECK_PARSE_NESTED_BOOL(FIELD, Enabled); \

‎clang/unittests/Format/FormatTest.cpp

Lines changed: 20 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -20010,6 +20010,17 @@ TEST_F(FormatTest, AlignConsecutiveDeclarations) {
2001020010
" return 0;\n"
2001120011
"}() };",
2001220012
BracedAlign);
20013+
20014+
Alignment.AlignConsecutiveDeclarations.AlignFunctionDeclarations = false;
20015+
verifyFormat("unsigned int f1(void);\n"
20016+
"void f2(void);\n"
20017+
"size_t f3(void);\n",
20018+
Alignment);
20019+
Alignment.AlignConsecutiveDeclarations.AlignFunctionDeclarations = true;
20020+
verifyFormat("unsigned int f1(void);\n"
20021+
"void f2(void);\n"
20022+
"size_t f3(void);\n",
20023+
Alignment);
2001320024
}
2001420025

2001520026
TEST_F(FormatTest, AlignConsecutiveShortCaseStatements) {
@@ -20253,9 +20264,16 @@ TEST_F(FormatTest, AlignWithLineBreaks) {
2025320264
FormatStyle::AlignConsecutiveStyle(
2025420265
{/*Enabled=*/false, /*AcrossEmptyLines=*/false,
2025520266
/*AcrossComments=*/false, /*AlignCompound=*/false,
20256-
/*AlignFunctionPointers=*/false, /*PadOperators=*/true}));
20267+
/*AlignFunctionDeclarations=*/false,
20268+
/*AlignFunctionPointers=*/false,
20269+
/*PadOperators=*/true}));
2025720270
EXPECT_EQ(Style.AlignConsecutiveDeclarations,
20258-
FormatStyle::AlignConsecutiveStyle({}));
20271+
FormatStyle::AlignConsecutiveStyle(
20272+
{/*Enabled=*/false, /*AcrossEmptyLines=*/false,
20273+
/*AcrossComments=*/false, /*AlignCompound=*/false,
20274+
/*AlignFunctionDeclarations=*/true,
20275+
/*AlignFunctionPointers=*/false,
20276+
/*PadOperators=*/false}));
2025920277
verifyFormat("void foo() {\n"
2026020278
" int myVar = 5;\n"
2026120279
" double x = 3.14;\n"

0 commit comments

Comments
 (0)