https://github.com/bradh352 updated
https://github.com/llvm/llvm-project/pull/108241
>From 89d238800f0287f29f95165e05530d3f5e397245 Mon Sep 17 00:00:00 2001
From: Brad House <b...@brad-house.com>
Date: Wed, 11 Sep 2024 10:27:50 -0400
Subject: [PATCH 1/2] 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 <b...@brad-house.com>
---
clang/docs/ClangFormatStyleOptions.rst | 105 +++++++++++++++++++++
clang/include/clang/Format/Format.h | 15 +++
clang/lib/Format/Format.cpp | 31 ++++--
clang/lib/Format/WhitespaceManager.cpp | 2 +-
clang/unittests/Format/ConfigParseTest.cpp | 18 ++--
clang/unittests/Format/FormatTest.cpp | 22 ++++-
6 files changed, 177 insertions(+), 16 deletions(-)
diff --git a/clang/docs/ClangFormatStyleOptions.rst
b/clang/docs/ClangFormatStyleOptions.rst
index a427d7cd40fcdd..c862d57a19b954 100644
--- a/clang/docs/ClangFormatStyleOptions.rst
+++ b/clang/docs/ClangFormatStyleOptions.rst
@@ -409,6 +409,21 @@ the configuration (without a prefix: ``Auto``).
int *p;
int (*f)();
+ * ``bool AlignFunctionDeclarations`` Only for
``AlignConsecutiveDeclarations``. Whether function declarations
+ are aligned.
+
+ .. code-block:: c++
+
+ true:
+ unsigned int f1(void);
+ void f2(void);
+ size_t f3(void);
+
+ false:
+ unsigned int f1(void);
+ void f2(void);
+ size_t f3(void);
+
* ``bool PadOperators`` Only for ``AlignConsecutiveAssignments``. Whether
short assignment
operators are left-padded to the same length as long ones in order to
put all assignment operators to the right of the left hand side.
@@ -551,6 +566,21 @@ the configuration (without a prefix: ``Auto``).
int *p;
int (*f)();
+ * ``bool AlignFunctionDeclarations`` Only for
``AlignConsecutiveDeclarations``. Whether function declarations
+ are aligned.
+
+ .. code-block:: c++
+
+ true:
+ unsigned int f1(void);
+ void f2(void);
+ size_t f3(void);
+
+ false:
+ unsigned int f1(void);
+ void f2(void);
+ size_t f3(void);
+
* ``bool PadOperators`` Only for ``AlignConsecutiveAssignments``. Whether
short assignment
operators are left-padded to the same length as long ones in order to
put all assignment operators to the right of the left hand side.
@@ -693,6 +723,21 @@ the configuration (without a prefix: ``Auto``).
int *p;
int (*f)();
+ * ``bool AlignFunctionDeclarations`` Only for
``AlignConsecutiveDeclarations``. Whether function declarations
+ are aligned.
+
+ .. code-block:: c++
+
+ true:
+ unsigned int f1(void);
+ void f2(void);
+ size_t f3(void);
+
+ false:
+ unsigned int f1(void);
+ void f2(void);
+ size_t f3(void);
+
* ``bool PadOperators`` Only for ``AlignConsecutiveAssignments``. Whether
short assignment
operators are left-padded to the same length as long ones in order to
put all assignment operators to the right of the left hand side.
@@ -836,6 +881,21 @@ the configuration (without a prefix: ``Auto``).
int *p;
int (*f)();
+ * ``bool AlignFunctionDeclarations`` Only for
``AlignConsecutiveDeclarations``. Whether function declarations
+ are aligned.
+
+ .. code-block:: c++
+
+ true:
+ unsigned int f1(void);
+ void f2(void);
+ size_t f3(void);
+
+ false:
+ unsigned int f1(void);
+ void f2(void);
+ size_t f3(void);
+
* ``bool PadOperators`` Only for ``AlignConsecutiveAssignments``. Whether
short assignment
operators are left-padded to the same length as long ones in order to
put all assignment operators to the right of the left hand side.
@@ -1098,6 +1158,21 @@ the configuration (without a prefix: ``Auto``).
int *p;
int (*f)();
+ * ``bool AlignFunctionDeclarations`` Only for
``AlignConsecutiveDeclarations``. Whether function declarations
+ are aligned.
+
+ .. code-block:: c++
+
+ true:
+ unsigned int f1(void);
+ void f2(void);
+ size_t f3(void);
+
+ false:
+ unsigned int f1(void);
+ void f2(void);
+ size_t f3(void);
+
* ``bool PadOperators`` Only for ``AlignConsecutiveAssignments``. Whether
short assignment
operators are left-padded to the same length as long ones in order to
put all assignment operators to the right of the left hand side.
@@ -1238,6 +1313,21 @@ the configuration (without a prefix: ``Auto``).
int *p;
int (*f)();
+ * ``bool AlignFunctionDeclarations`` Only for
``AlignConsecutiveDeclarations``. Whether function declarations
+ are aligned.
+
+ .. code-block:: c++
+
+ true:
+ unsigned int f1(void);
+ void f2(void);
+ size_t f3(void);
+
+ false:
+ unsigned int f1(void);
+ void f2(void);
+ size_t f3(void);
+
* ``bool PadOperators`` Only for ``AlignConsecutiveAssignments``. Whether
short assignment
operators are left-padded to the same length as long ones in order to
put all assignment operators to the right of the left hand side.
@@ -1378,6 +1468,21 @@ the configuration (without a prefix: ``Auto``).
int *p;
int (*f)();
+ * ``bool AlignFunctionDeclarations`` Only for
``AlignConsecutiveDeclarations``. Whether function declarations
+ are aligned.
+
+ .. code-block:: c++
+
+ true:
+ unsigned int f1(void);
+ void f2(void);
+ size_t f3(void);
+
+ false:
+ unsigned int f1(void);
+ void f2(void);
+ size_t f3(void);
+
* ``bool PadOperators`` Only for ``AlignConsecutiveAssignments``. Whether
short assignment
operators are left-padded to the same length as long ones in order to
put all assignment operators to the right of the left hand side.
diff --git a/clang/include/clang/Format/Format.h
b/clang/include/clang/Format/Format.h
index d8b62c7652a0f6..23aa98128d02ae 100644
--- a/clang/include/clang/Format/Format.h
+++ b/clang/include/clang/Format/Format.h
@@ -241,6 +241,20 @@ struct FormatStyle {
/// int (*f)();
/// \endcode
bool AlignFunctionPointers;
+ /// Only for ``AlignConsecutiveDeclarations``. Whether function
declarations
+ /// are aligned.
+ /// \code
+ /// true:
+ /// unsigned int f1(void);
+ /// void f2(void);
+ /// size_t f3(void);
+ ///
+ /// false:
+ /// unsigned int f1(void);
+ /// void f2(void);
+ /// size_t f3(void);
+ /// \endcode
+ bool AlignFunctionDeclarations;
/// Only for ``AlignConsecutiveAssignments``. Whether short assignment
/// operators are left-padded to the same length as long ones in order to
/// put all assignment operators to the right of the left hand side.
@@ -265,6 +279,7 @@ struct FormatStyle {
AcrossComments == R.AcrossComments &&
AlignCompound == R.AlignCompound &&
AlignFunctionPointers == R.AlignFunctionPointers &&
+ AlignFunctionDeclarations == R.AlignFunctionDeclarations &&
PadOperators == R.PadOperators;
}
bool operator!=(const AlignConsecutiveStyle &R) const {
diff --git a/clang/lib/Format/Format.cpp b/clang/lib/Format/Format.cpp
index d2463b892fbb96..9d0d2740a29da1 100644
--- a/clang/lib/Format/Format.cpp
+++ b/clang/lib/Format/Format.cpp
@@ -48,39 +48,53 @@ template <> struct
MappingTraits<FormatStyle::AlignConsecutiveStyle> {
FormatStyle::AlignConsecutiveStyle(
{/*Enabled=*/false, /*AcrossEmptyLines=*/false,
/*AcrossComments=*/false, /*AlignCompound=*/false,
- /*AlignFunctionPointers=*/false, /*PadOperators=*/true}));
+ /*AlignFunctionPointers=*/false,
+ /*AlignFunctionDeclarations=*/true,
+ /*PadOperators=*/true}));
IO.enumCase(Value, "Consecutive",
FormatStyle::AlignConsecutiveStyle(
{/*Enabled=*/true, /*AcrossEmptyLines=*/false,
/*AcrossComments=*/false, /*AlignCompound=*/false,
- /*AlignFunctionPointers=*/false, /*PadOperators=*/true}));
+ /*AlignFunctionPointers=*/false,
+ /*AlignFunctionDeclarations=*/true,
+ /*PadOperators=*/true}));
IO.enumCase(Value, "AcrossEmptyLines",
FormatStyle::AlignConsecutiveStyle(
{/*Enabled=*/true, /*AcrossEmptyLines=*/true,
/*AcrossComments=*/false, /*AlignCompound=*/false,
- /*AlignFunctionPointers=*/false, /*PadOperators=*/true}));
+ /*AlignFunctionPointers=*/false,
+ /*AlignFunctionDeclarations=*/true,
+ /*PadOperators=*/true}));
IO.enumCase(Value, "AcrossComments",
FormatStyle::AlignConsecutiveStyle(
{/*Enabled=*/true, /*AcrossEmptyLines=*/false,
/*AcrossComments=*/true, /*AlignCompound=*/false,
- /*AlignFunctionPointers=*/false, /*PadOperators=*/true}));
+ /*AlignFunctionPointers=*/false,
+ /*AlignFunctionDeclarations=*/true,
+ /*PadOperators=*/true}));
IO.enumCase(Value, "AcrossEmptyLinesAndComments",
FormatStyle::AlignConsecutiveStyle(
{/*Enabled=*/true, /*AcrossEmptyLines=*/true,
/*AcrossComments=*/true, /*AlignCompound=*/false,
- /*AlignFunctionPointers=*/false, /*PadOperators=*/true}));
+ /*AlignFunctionPointers=*/false,
+ /*AlignFunctionDeclarations=*/true,
+ /*PadOperators=*/true}));
// For backward compatibility.
IO.enumCase(Value, "true",
FormatStyle::AlignConsecutiveStyle(
{/*Enabled=*/true, /*AcrossEmptyLines=*/false,
/*AcrossComments=*/false, /*AlignCompound=*/false,
- /*AlignFunctionPointers=*/false, /*PadOperators=*/true}));
+ /*AlignFunctionPointers=*/false,
+ /*AlignFunctionDeclarations=*/true,
+ /*PadOperators=*/true}));
IO.enumCase(Value, "false",
FormatStyle::AlignConsecutiveStyle(
{/*Enabled=*/false, /*AcrossEmptyLines=*/false,
/*AcrossComments=*/false, /*AlignCompound=*/false,
- /*AlignFunctionPointers=*/false, /*PadOperators=*/true}));
+ /*AlignFunctionPointers=*/false,
+ /*AlignFunctionDeclarations=*/true,
+ /*PadOperators=*/true}));
}
static void mapping(IO &IO, FormatStyle::AlignConsecutiveStyle &Value) {
@@ -89,6 +103,8 @@ template <> struct
MappingTraits<FormatStyle::AlignConsecutiveStyle> {
IO.mapOptional("AcrossComments", Value.AcrossComments);
IO.mapOptional("AlignCompound", Value.AlignCompound);
IO.mapOptional("AlignFunctionPointers", Value.AlignFunctionPointers);
+ IO.mapOptional("AlignFunctionDeclarations",
+ Value.AlignFunctionDeclarations);
IO.mapOptional("PadOperators", Value.PadOperators);
}
};
@@ -1448,6 +1464,7 @@ FormatStyle getLLVMStyle(FormatStyle::LanguageKind
Language) {
LLVMStyle.AlignConsecutiveAssignments.PadOperators = true;
LLVMStyle.AlignConsecutiveBitFields = {};
LLVMStyle.AlignConsecutiveDeclarations = {};
+ LLVMStyle.AlignConsecutiveDeclarations.AlignFunctionDeclarations = true;
LLVMStyle.AlignConsecutiveMacros = {};
LLVMStyle.AlignConsecutiveShortCaseStatements = {};
LLVMStyle.AlignConsecutiveTableGenBreakingDAGArgColons = {};
diff --git a/clang/lib/Format/WhitespaceManager.cpp
b/clang/lib/Format/WhitespaceManager.cpp
index fd4a40a86082e2..b6b24672f6a39d 100644
--- a/clang/lib/Format/WhitespaceManager.cpp
+++ b/clang/lib/Format/WhitespaceManager.cpp
@@ -1020,7 +1020,7 @@ void WhitespaceManager::alignConsecutiveDeclarations() {
return true;
}
if (C.Tok->is(TT_FunctionDeclarationName))
- return true;
+ return Style.AlignConsecutiveDeclarations.AlignFunctionDeclarations;
if (C.Tok->isNot(TT_StartOfName))
return false;
if (C.Tok->Previous &&
diff --git a/clang/unittests/Format/ConfigParseTest.cpp
b/clang/unittests/Format/ConfigParseTest.cpp
index b8bdfaaa74e10e..bef0f06b15db4c 100644
--- a/clang/unittests/Format/ConfigParseTest.cpp
+++ b/clang/unittests/Format/ConfigParseTest.cpp
@@ -305,38 +305,44 @@ TEST(ConfigParseTest, ParsesConfiguration) {
FormatStyle::AlignConsecutiveStyle(
\
{/*Enabled=*/false, /*AcrossEmptyLines=*/false,
\
/*AcrossComments=*/false, /*AlignCompound=*/false,
\
- /*AlignFunctionPointers=*/false, /*PadOperators=*/true}));
\
+ /*AlignFunctionPointers=*/false,
\
+ /*AlignFunctionDeclarations=*/true, /*PadOperators=*/true}));
\
CHECK_PARSE(
\
#FIELD ": Consecutive", FIELD,
\
FormatStyle::AlignConsecutiveStyle(
\
{/*Enabled=*/true, /*AcrossEmptyLines=*/false,
\
/*AcrossComments=*/false, /*AlignCompound=*/false,
\
- /*AlignFunctionPointers=*/false, /*PadOperators=*/true}));
\
+ /*AlignFunctionPointers=*/false,
\
+ /*AlignFunctionDeclarations=*/true, /*PadOperators=*/true}));
\
CHECK_PARSE(
\
#FIELD ": AcrossEmptyLines", FIELD,
\
FormatStyle::AlignConsecutiveStyle(
\
{/*Enabled=*/true, /*AcrossEmptyLines=*/true,
\
/*AcrossComments=*/false, /*AlignCompound=*/false,
\
- /*AlignFunctionPointers=*/false, /*PadOperators=*/true}));
\
+ /*AlignFunctionPointers=*/false,
\
+ /*AlignFunctionDeclarations=*/true, /*PadOperators=*/true}));
\
CHECK_PARSE(
\
#FIELD ": AcrossEmptyLinesAndComments", FIELD,
\
FormatStyle::AlignConsecutiveStyle(
\
{/*Enabled=*/true, /*AcrossEmptyLines=*/true,
\
/*AcrossComments=*/true, /*AlignCompound=*/false,
\
- /*AlignFunctionPointers=*/false, /*PadOperators=*/true}));
\
+ /*AlignFunctionPointers=*/false,
\
+ /*AlignFunctionDeclarations=*/true, /*PadOperators=*/true}));
\
/* For backwards compability, false / true should still parse */
\
CHECK_PARSE(
\
#FIELD ": false", FIELD,
\
FormatStyle::AlignConsecutiveStyle(
\
{/*Enabled=*/false, /*AcrossEmptyLines=*/false,
\
/*AcrossComments=*/false, /*AlignCompound=*/false,
\
- /*AlignFunctionPointers=*/false, /*PadOperators=*/true}));
\
+ /*AlignFunctionPointers=*/false,
\
+ /*AlignFunctionDeclarations=*/true, /*PadOperators=*/true}));
\
CHECK_PARSE(
\
#FIELD ": true", FIELD,
\
FormatStyle::AlignConsecutiveStyle(
\
{/*Enabled=*/true, /*AcrossEmptyLines=*/false,
\
/*AcrossComments=*/false, /*AlignCompound=*/false,
\
- /*AlignFunctionPointers=*/false, /*PadOperators=*/true}));
\
+ /*AlignFunctionPointers=*/false,
\
+ /*AlignFunctionDeclarations=*/true, /*PadOperators=*/true}));
\
\
CHECK_PARSE_NESTED_BOOL(FIELD, Enabled);
\
CHECK_PARSE_NESTED_BOOL(FIELD, AcrossEmptyLines);
\
diff --git a/clang/unittests/Format/FormatTest.cpp
b/clang/unittests/Format/FormatTest.cpp
index 5ebf0d7068dd6c..6a41179bc2d2fc 100644
--- a/clang/unittests/Format/FormatTest.cpp
+++ b/clang/unittests/Format/FormatTest.cpp
@@ -20010,6 +20010,17 @@ TEST_F(FormatTest, AlignConsecutiveDeclarations) {
" return 0;\n"
"}() };",
BracedAlign);
+
+ Alignment.AlignConsecutiveDeclarations.AlignFunctionDeclarations = false;
+ verifyFormat("unsigned int f1(void);\n"
+ "void f2(void);\n"
+ "size_t f3(void);\n",
+ Alignment);
+ Alignment.AlignConsecutiveDeclarations.AlignFunctionDeclarations = true;
+ verifyFormat("unsigned int f1(void);\n"
+ "void f2(void);\n"
+ "size_t f3(void);\n",
+ Alignment);
}
TEST_F(FormatTest, AlignConsecutiveShortCaseStatements) {
@@ -20253,9 +20264,16 @@ TEST_F(FormatTest, AlignWithLineBreaks) {
FormatStyle::AlignConsecutiveStyle(
{/*Enabled=*/false, /*AcrossEmptyLines=*/false,
/*AcrossComments=*/false, /*AlignCompound=*/false,
- /*AlignFunctionPointers=*/false, /*PadOperators=*/true}));
+ /*AlignFunctionPointers=*/false,
+ /*AlignFunctionDeclarations=*/false,
+ /*PadOperators=*/true}));
EXPECT_EQ(Style.AlignConsecutiveDeclarations,
- FormatStyle::AlignConsecutiveStyle({}));
+ FormatStyle::AlignConsecutiveStyle(
+ {/*Enabled=*/false, /*AcrossEmptyLines=*/false,
+ /*AcrossComments=*/false, /*AlignCompound=*/false,
+ /*AlignFunctionPointers=*/false,
+ /*AlignFunctionDeclarations=*/true,
+ /*PadOperators=*/false}));
verifyFormat("void foo() {\n"
" int myVar = 5;\n"
" double x = 3.14;\n"
>From 2bbadfe834c9b8cb5b70ec35ca67ec1da04caa4b Mon Sep 17 00:00:00 2001
From: Brad House <b...@brad-house.com>
Date: Wed, 18 Sep 2024 06:28:32 -0400
Subject: [PATCH 2/2] sort alphabetically and add clang version 20
---
clang/docs/ClangFormatStyleOptions.rst | 245 +++++++++++----------
clang/include/clang/Format/Format.h | 31 +--
clang/lib/Format/Format.cpp | 16 +-
clang/unittests/Format/ConfigParseTest.cpp | 24 +-
clang/unittests/Format/FormatTest.cpp | 4 +-
5 files changed, 164 insertions(+), 156 deletions(-)
diff --git a/clang/docs/ClangFormatStyleOptions.rst
b/clang/docs/ClangFormatStyleOptions.rst
index c862d57a19b954..b0e5901c4e68a0 100644
--- a/clang/docs/ClangFormatStyleOptions.rst
+++ b/clang/docs/ClangFormatStyleOptions.rst
@@ -392,7 +392,8 @@ the configuration (without a prefix: ``Auto``).
a &= 2;
bbb = 2;
- * ``bool AlignFunctionPointers`` Only for ``AlignConsecutiveDeclarations``.
Whether function pointers are
+ * ``bool AlignFunctionDeclarations`` :versionbadge:`clang-format 20`
+ Only for ``AlignConsecutiveDeclarations``. Whether function pointers are
aligned.
.. code-block:: c++
@@ -409,22 +410,7 @@ the configuration (without a prefix: ``Auto``).
int *p;
int (*f)();
- * ``bool AlignFunctionDeclarations`` Only for
``AlignConsecutiveDeclarations``. Whether function declarations
- are aligned.
-
- .. code-block:: c++
-
- true:
- unsigned int f1(void);
- void f2(void);
- size_t f3(void);
-
- false:
- unsigned int f1(void);
- void f2(void);
- size_t f3(void);
-
- * ``bool PadOperators`` Only for ``AlignConsecutiveAssignments``. Whether
short assignment
+ * ``bool AlignFunctionPointers`` Only for ``AlignConsecutiveAssignments``.
Whether short assignment
operators are left-padded to the same length as long ones in order to
put all assignment operators to the right of the left hand side.
@@ -444,6 +430,21 @@ the configuration (without a prefix: ``Auto``).
a = 2;
bbb >>= 2;
+ * ``bool PadOperators`` Only for ``AlignConsecutiveDeclarations``. Whether
function declarations
+ are aligned.
+
+ .. code-block:: c++
+
+ true:
+ unsigned int f1(void);
+ void f2(void);
+ size_t f3(void);
+
+ false:
+ unsigned int f1(void);
+ void f2(void);
+ size_t f3(void);
+
.. _AlignConsecutiveBitFields:
@@ -549,7 +550,8 @@ the configuration (without a prefix: ``Auto``).
a &= 2;
bbb = 2;
- * ``bool AlignFunctionPointers`` Only for ``AlignConsecutiveDeclarations``.
Whether function pointers are
+ * ``bool AlignFunctionDeclarations`` :versionbadge:`clang-format 20`
+ Only for ``AlignConsecutiveDeclarations``. Whether function pointers are
aligned.
.. code-block:: c++
@@ -566,22 +568,7 @@ the configuration (without a prefix: ``Auto``).
int *p;
int (*f)();
- * ``bool AlignFunctionDeclarations`` Only for
``AlignConsecutiveDeclarations``. Whether function declarations
- are aligned.
-
- .. code-block:: c++
-
- true:
- unsigned int f1(void);
- void f2(void);
- size_t f3(void);
-
- false:
- unsigned int f1(void);
- void f2(void);
- size_t f3(void);
-
- * ``bool PadOperators`` Only for ``AlignConsecutiveAssignments``. Whether
short assignment
+ * ``bool AlignFunctionPointers`` Only for ``AlignConsecutiveAssignments``.
Whether short assignment
operators are left-padded to the same length as long ones in order to
put all assignment operators to the right of the left hand side.
@@ -601,6 +588,21 @@ the configuration (without a prefix: ``Auto``).
a = 2;
bbb >>= 2;
+ * ``bool PadOperators`` Only for ``AlignConsecutiveDeclarations``. Whether
function declarations
+ are aligned.
+
+ .. code-block:: c++
+
+ true:
+ unsigned int f1(void);
+ void f2(void);
+ size_t f3(void);
+
+ false:
+ unsigned int f1(void);
+ void f2(void);
+ size_t f3(void);
+
.. _AlignConsecutiveDeclarations:
@@ -706,7 +708,8 @@ the configuration (without a prefix: ``Auto``).
a &= 2;
bbb = 2;
- * ``bool AlignFunctionPointers`` Only for ``AlignConsecutiveDeclarations``.
Whether function pointers are
+ * ``bool AlignFunctionDeclarations`` :versionbadge:`clang-format 20`
+ Only for ``AlignConsecutiveDeclarations``. Whether function pointers are
aligned.
.. code-block:: c++
@@ -723,22 +726,7 @@ the configuration (without a prefix: ``Auto``).
int *p;
int (*f)();
- * ``bool AlignFunctionDeclarations`` Only for
``AlignConsecutiveDeclarations``. Whether function declarations
- are aligned.
-
- .. code-block:: c++
-
- true:
- unsigned int f1(void);
- void f2(void);
- size_t f3(void);
-
- false:
- unsigned int f1(void);
- void f2(void);
- size_t f3(void);
-
- * ``bool PadOperators`` Only for ``AlignConsecutiveAssignments``. Whether
short assignment
+ * ``bool AlignFunctionPointers`` Only for ``AlignConsecutiveAssignments``.
Whether short assignment
operators are left-padded to the same length as long ones in order to
put all assignment operators to the right of the left hand side.
@@ -758,6 +746,21 @@ the configuration (without a prefix: ``Auto``).
a = 2;
bbb >>= 2;
+ * ``bool PadOperators`` Only for ``AlignConsecutiveDeclarations``. Whether
function declarations
+ are aligned.
+
+ .. code-block:: c++
+
+ true:
+ unsigned int f1(void);
+ void f2(void);
+ size_t f3(void);
+
+ false:
+ unsigned int f1(void);
+ void f2(void);
+ size_t f3(void);
+
.. _AlignConsecutiveMacros:
@@ -864,7 +867,8 @@ the configuration (without a prefix: ``Auto``).
a &= 2;
bbb = 2;
- * ``bool AlignFunctionPointers`` Only for ``AlignConsecutiveDeclarations``.
Whether function pointers are
+ * ``bool AlignFunctionDeclarations`` :versionbadge:`clang-format 20`
+ Only for ``AlignConsecutiveDeclarations``. Whether function pointers are
aligned.
.. code-block:: c++
@@ -881,22 +885,7 @@ the configuration (without a prefix: ``Auto``).
int *p;
int (*f)();
- * ``bool AlignFunctionDeclarations`` Only for
``AlignConsecutiveDeclarations``. Whether function declarations
- are aligned.
-
- .. code-block:: c++
-
- true:
- unsigned int f1(void);
- void f2(void);
- size_t f3(void);
-
- false:
- unsigned int f1(void);
- void f2(void);
- size_t f3(void);
-
- * ``bool PadOperators`` Only for ``AlignConsecutiveAssignments``. Whether
short assignment
+ * ``bool AlignFunctionPointers`` Only for ``AlignConsecutiveAssignments``.
Whether short assignment
operators are left-padded to the same length as long ones in order to
put all assignment operators to the right of the left hand side.
@@ -916,6 +905,21 @@ the configuration (without a prefix: ``Auto``).
a = 2;
bbb >>= 2;
+ * ``bool PadOperators`` Only for ``AlignConsecutiveDeclarations``. Whether
function declarations
+ are aligned.
+
+ .. code-block:: c++
+
+ true:
+ unsigned int f1(void);
+ void f2(void);
+ size_t f3(void);
+
+ false:
+ unsigned int f1(void);
+ void f2(void);
+ size_t f3(void);
+
.. _AlignConsecutiveShortCaseStatements:
@@ -1141,7 +1145,8 @@ the configuration (without a prefix: ``Auto``).
a &= 2;
bbb = 2;
- * ``bool AlignFunctionPointers`` Only for ``AlignConsecutiveDeclarations``.
Whether function pointers are
+ * ``bool AlignFunctionDeclarations`` :versionbadge:`clang-format 20`
+ Only for ``AlignConsecutiveDeclarations``. Whether function pointers are
aligned.
.. code-block:: c++
@@ -1158,22 +1163,7 @@ the configuration (without a prefix: ``Auto``).
int *p;
int (*f)();
- * ``bool AlignFunctionDeclarations`` Only for
``AlignConsecutiveDeclarations``. Whether function declarations
- are aligned.
-
- .. code-block:: c++
-
- true:
- unsigned int f1(void);
- void f2(void);
- size_t f3(void);
-
- false:
- unsigned int f1(void);
- void f2(void);
- size_t f3(void);
-
- * ``bool PadOperators`` Only for ``AlignConsecutiveAssignments``. Whether
short assignment
+ * ``bool AlignFunctionPointers`` Only for ``AlignConsecutiveAssignments``.
Whether short assignment
operators are left-padded to the same length as long ones in order to
put all assignment operators to the right of the left hand side.
@@ -1193,6 +1183,21 @@ the configuration (without a prefix: ``Auto``).
a = 2;
bbb >>= 2;
+ * ``bool PadOperators`` Only for ``AlignConsecutiveDeclarations``. Whether
function declarations
+ are aligned.
+
+ .. code-block:: c++
+
+ true:
+ unsigned int f1(void);
+ void f2(void);
+ size_t f3(void);
+
+ false:
+ unsigned int f1(void);
+ void f2(void);
+ size_t f3(void);
+
.. _AlignConsecutiveTableGenCondOperatorColons:
@@ -1296,7 +1301,8 @@ the configuration (without a prefix: ``Auto``).
a &= 2;
bbb = 2;
- * ``bool AlignFunctionPointers`` Only for ``AlignConsecutiveDeclarations``.
Whether function pointers are
+ * ``bool AlignFunctionDeclarations`` :versionbadge:`clang-format 20`
+ Only for ``AlignConsecutiveDeclarations``. Whether function pointers are
aligned.
.. code-block:: c++
@@ -1313,22 +1319,7 @@ the configuration (without a prefix: ``Auto``).
int *p;
int (*f)();
- * ``bool AlignFunctionDeclarations`` Only for
``AlignConsecutiveDeclarations``. Whether function declarations
- are aligned.
-
- .. code-block:: c++
-
- true:
- unsigned int f1(void);
- void f2(void);
- size_t f3(void);
-
- false:
- unsigned int f1(void);
- void f2(void);
- size_t f3(void);
-
- * ``bool PadOperators`` Only for ``AlignConsecutiveAssignments``. Whether
short assignment
+ * ``bool AlignFunctionPointers`` Only for ``AlignConsecutiveAssignments``.
Whether short assignment
operators are left-padded to the same length as long ones in order to
put all assignment operators to the right of the left hand side.
@@ -1348,6 +1339,21 @@ the configuration (without a prefix: ``Auto``).
a = 2;
bbb >>= 2;
+ * ``bool PadOperators`` Only for ``AlignConsecutiveDeclarations``. Whether
function declarations
+ are aligned.
+
+ .. code-block:: c++
+
+ true:
+ unsigned int f1(void);
+ void f2(void);
+ size_t f3(void);
+
+ false:
+ unsigned int f1(void);
+ void f2(void);
+ size_t f3(void);
+
.. _AlignConsecutiveTableGenDefinitionColons:
@@ -1451,7 +1457,8 @@ the configuration (without a prefix: ``Auto``).
a &= 2;
bbb = 2;
- * ``bool AlignFunctionPointers`` Only for ``AlignConsecutiveDeclarations``.
Whether function pointers are
+ * ``bool AlignFunctionDeclarations`` :versionbadge:`clang-format 20`
+ Only for ``AlignConsecutiveDeclarations``. Whether function pointers are
aligned.
.. code-block:: c++
@@ -1468,22 +1475,7 @@ the configuration (without a prefix: ``Auto``).
int *p;
int (*f)();
- * ``bool AlignFunctionDeclarations`` Only for
``AlignConsecutiveDeclarations``. Whether function declarations
- are aligned.
-
- .. code-block:: c++
-
- true:
- unsigned int f1(void);
- void f2(void);
- size_t f3(void);
-
- false:
- unsigned int f1(void);
- void f2(void);
- size_t f3(void);
-
- * ``bool PadOperators`` Only for ``AlignConsecutiveAssignments``. Whether
short assignment
+ * ``bool AlignFunctionPointers`` Only for ``AlignConsecutiveAssignments``.
Whether short assignment
operators are left-padded to the same length as long ones in order to
put all assignment operators to the right of the left hand side.
@@ -1503,6 +1495,21 @@ the configuration (without a prefix: ``Auto``).
a = 2;
bbb >>= 2;
+ * ``bool PadOperators`` Only for ``AlignConsecutiveDeclarations``. Whether
function declarations
+ are aligned.
+
+ .. code-block:: c++
+
+ true:
+ unsigned int f1(void);
+ void f2(void);
+ size_t f3(void);
+
+ false:
+ unsigned int f1(void);
+ void f2(void);
+ size_t f3(void);
+
.. _AlignEscapedNewlines:
diff --git a/clang/include/clang/Format/Format.h
b/clang/include/clang/Format/Format.h
index 23aa98128d02ae..7828207a81436b 100644
--- a/clang/include/clang/Format/Format.h
+++ b/clang/include/clang/Format/Format.h
@@ -240,20 +240,7 @@ struct FormatStyle {
/// int *p;
/// int (*f)();
/// \endcode
- bool AlignFunctionPointers;
- /// Only for ``AlignConsecutiveDeclarations``. Whether function
declarations
- /// are aligned.
- /// \code
- /// true:
- /// unsigned int f1(void);
- /// void f2(void);
- /// size_t f3(void);
- ///
- /// false:
- /// unsigned int f1(void);
- /// void f2(void);
- /// size_t f3(void);
- /// \endcode
+ /// \version 20
bool AlignFunctionDeclarations;
/// Only for ``AlignConsecutiveAssignments``. Whether short assignment
/// operators are left-padded to the same length as long ones in order to
@@ -273,13 +260,27 @@ struct FormatStyle {
/// a = 2;
/// bbb >>= 2;
/// \endcode
+ bool AlignFunctionPointers;
+ /// Only for ``AlignConsecutiveDeclarations``. Whether function
declarations
+ /// are aligned.
+ /// \code
+ /// true:
+ /// unsigned int f1(void);
+ /// void f2(void);
+ /// size_t f3(void);
+ ///
+ /// false:
+ /// unsigned int f1(void);
+ /// void f2(void);
+ /// size_t f3(void);
+ /// \endcode
bool PadOperators;
bool operator==(const AlignConsecutiveStyle &R) const {
return Enabled == R.Enabled && AcrossEmptyLines == R.AcrossEmptyLines &&
AcrossComments == R.AcrossComments &&
AlignCompound == R.AlignCompound &&
- AlignFunctionPointers == R.AlignFunctionPointers &&
AlignFunctionDeclarations == R.AlignFunctionDeclarations &&
+ AlignFunctionPointers == R.AlignFunctionPointers &&
PadOperators == R.PadOperators;
}
bool operator!=(const AlignConsecutiveStyle &R) const {
diff --git a/clang/lib/Format/Format.cpp b/clang/lib/Format/Format.cpp
index 9d0d2740a29da1..9bd12dd6b4dc71 100644
--- a/clang/lib/Format/Format.cpp
+++ b/clang/lib/Format/Format.cpp
@@ -48,36 +48,36 @@ template <> struct
MappingTraits<FormatStyle::AlignConsecutiveStyle> {
FormatStyle::AlignConsecutiveStyle(
{/*Enabled=*/false, /*AcrossEmptyLines=*/false,
/*AcrossComments=*/false, /*AlignCompound=*/false,
- /*AlignFunctionPointers=*/false,
/*AlignFunctionDeclarations=*/true,
+ /*AlignFunctionPointers=*/false,
/*PadOperators=*/true}));
IO.enumCase(Value, "Consecutive",
FormatStyle::AlignConsecutiveStyle(
{/*Enabled=*/true, /*AcrossEmptyLines=*/false,
/*AcrossComments=*/false, /*AlignCompound=*/false,
- /*AlignFunctionPointers=*/false,
/*AlignFunctionDeclarations=*/true,
+ /*AlignFunctionPointers=*/false,
/*PadOperators=*/true}));
IO.enumCase(Value, "AcrossEmptyLines",
FormatStyle::AlignConsecutiveStyle(
{/*Enabled=*/true, /*AcrossEmptyLines=*/true,
/*AcrossComments=*/false, /*AlignCompound=*/false,
- /*AlignFunctionPointers=*/false,
/*AlignFunctionDeclarations=*/true,
+ /*AlignFunctionPointers=*/false,
/*PadOperators=*/true}));
IO.enumCase(Value, "AcrossComments",
FormatStyle::AlignConsecutiveStyle(
{/*Enabled=*/true, /*AcrossEmptyLines=*/false,
/*AcrossComments=*/true, /*AlignCompound=*/false,
- /*AlignFunctionPointers=*/false,
/*AlignFunctionDeclarations=*/true,
+ /*AlignFunctionPointers=*/false,
/*PadOperators=*/true}));
IO.enumCase(Value, "AcrossEmptyLinesAndComments",
FormatStyle::AlignConsecutiveStyle(
{/*Enabled=*/true, /*AcrossEmptyLines=*/true,
/*AcrossComments=*/true, /*AlignCompound=*/false,
- /*AlignFunctionPointers=*/false,
/*AlignFunctionDeclarations=*/true,
+ /*AlignFunctionPointers=*/false,
/*PadOperators=*/true}));
// For backward compatibility.
@@ -85,15 +85,15 @@ template <> struct
MappingTraits<FormatStyle::AlignConsecutiveStyle> {
FormatStyle::AlignConsecutiveStyle(
{/*Enabled=*/true, /*AcrossEmptyLines=*/false,
/*AcrossComments=*/false, /*AlignCompound=*/false,
- /*AlignFunctionPointers=*/false,
/*AlignFunctionDeclarations=*/true,
+ /*AlignFunctionPointers=*/false,
/*PadOperators=*/true}));
IO.enumCase(Value, "false",
FormatStyle::AlignConsecutiveStyle(
{/*Enabled=*/false, /*AcrossEmptyLines=*/false,
/*AcrossComments=*/false, /*AlignCompound=*/false,
- /*AlignFunctionPointers=*/false,
/*AlignFunctionDeclarations=*/true,
+ /*AlignFunctionPointers=*/false,
/*PadOperators=*/true}));
}
@@ -102,9 +102,9 @@ template <> struct
MappingTraits<FormatStyle::AlignConsecutiveStyle> {
IO.mapOptional("AcrossEmptyLines", Value.AcrossEmptyLines);
IO.mapOptional("AcrossComments", Value.AcrossComments);
IO.mapOptional("AlignCompound", Value.AlignCompound);
- IO.mapOptional("AlignFunctionPointers", Value.AlignFunctionPointers);
IO.mapOptional("AlignFunctionDeclarations",
Value.AlignFunctionDeclarations);
+ IO.mapOptional("AlignFunctionPointers", Value.AlignFunctionPointers);
IO.mapOptional("PadOperators", Value.PadOperators);
}
};
diff --git a/clang/unittests/Format/ConfigParseTest.cpp
b/clang/unittests/Format/ConfigParseTest.cpp
index bef0f06b15db4c..938eac99114a36 100644
--- a/clang/unittests/Format/ConfigParseTest.cpp
+++ b/clang/unittests/Format/ConfigParseTest.cpp
@@ -305,44 +305,44 @@ TEST(ConfigParseTest, ParsesConfiguration) {
FormatStyle::AlignConsecutiveStyle(
\
{/*Enabled=*/false, /*AcrossEmptyLines=*/false,
\
/*AcrossComments=*/false, /*AlignCompound=*/false,
\
- /*AlignFunctionPointers=*/false,
\
- /*AlignFunctionDeclarations=*/true, /*PadOperators=*/true}));
\
+ /*AlignFunctionDeclarations=*/true,
\
+ /*AlignFunctionPointers=*/false, /*PadOperators=*/true}));
\
CHECK_PARSE(
\
#FIELD ": Consecutive", FIELD,
\
FormatStyle::AlignConsecutiveStyle(
\
{/*Enabled=*/true, /*AcrossEmptyLines=*/false,
\
/*AcrossComments=*/false, /*AlignCompound=*/false,
\
- /*AlignFunctionPointers=*/false,
\
- /*AlignFunctionDeclarations=*/true, /*PadOperators=*/true}));
\
+ /*AlignFunctionDeclarations=*/true,
\
+ /*AlignFunctionPointers=*/false, /*PadOperators=*/true}));
\
CHECK_PARSE(
\
#FIELD ": AcrossEmptyLines", FIELD,
\
FormatStyle::AlignConsecutiveStyle(
\
{/*Enabled=*/true, /*AcrossEmptyLines=*/true,
\
/*AcrossComments=*/false, /*AlignCompound=*/false,
\
- /*AlignFunctionPointers=*/false,
\
- /*AlignFunctionDeclarations=*/true, /*PadOperators=*/true}));
\
+ /*AlignFunctionDeclarations=*/true,
\
+ /*AlignFunctionPointers=*/false, /*PadOperators=*/true}));
\
CHECK_PARSE(
\
#FIELD ": AcrossEmptyLinesAndComments", FIELD,
\
FormatStyle::AlignConsecutiveStyle(
\
{/*Enabled=*/true, /*AcrossEmptyLines=*/true,
\
/*AcrossComments=*/true, /*AlignCompound=*/false,
\
- /*AlignFunctionPointers=*/false,
\
- /*AlignFunctionDeclarations=*/true, /*PadOperators=*/true}));
\
+ /*AlignFunctionDeclarations=*/true,
\
+ /*AlignFunctionPointers=*/false, /*PadOperators=*/true}));
\
/* For backwards compability, false / true should still parse */
\
CHECK_PARSE(
\
#FIELD ": false", FIELD,
\
FormatStyle::AlignConsecutiveStyle(
\
{/*Enabled=*/false, /*AcrossEmptyLines=*/false,
\
/*AcrossComments=*/false, /*AlignCompound=*/false,
\
- /*AlignFunctionPointers=*/false,
\
- /*AlignFunctionDeclarations=*/true, /*PadOperators=*/true}));
\
+ /*AlignFunctionDeclarations=*/true,
\
+ /*AlignFunctionPointers=*/false, /*PadOperators=*/true}));
\
CHECK_PARSE(
\
#FIELD ": true", FIELD,
\
FormatStyle::AlignConsecutiveStyle(
\
{/*Enabled=*/true, /*AcrossEmptyLines=*/false,
\
/*AcrossComments=*/false, /*AlignCompound=*/false,
\
- /*AlignFunctionPointers=*/false,
\
- /*AlignFunctionDeclarations=*/true, /*PadOperators=*/true}));
\
+ /*AlignFunctionDeclarations=*/true,
\
+ /*AlignFunctionPointers=*/false, /*PadOperators=*/true}));
\
\
CHECK_PARSE_NESTED_BOOL(FIELD, Enabled);
\
CHECK_PARSE_NESTED_BOOL(FIELD, AcrossEmptyLines);
\
diff --git a/clang/unittests/Format/FormatTest.cpp
b/clang/unittests/Format/FormatTest.cpp
index 6a41179bc2d2fc..22cecc01484693 100644
--- a/clang/unittests/Format/FormatTest.cpp
+++ b/clang/unittests/Format/FormatTest.cpp
@@ -20264,15 +20264,15 @@ TEST_F(FormatTest, AlignWithLineBreaks) {
FormatStyle::AlignConsecutiveStyle(
{/*Enabled=*/false, /*AcrossEmptyLines=*/false,
/*AcrossComments=*/false, /*AlignCompound=*/false,
- /*AlignFunctionPointers=*/false,
/*AlignFunctionDeclarations=*/false,
+ /*AlignFunctionPointers=*/false,
/*PadOperators=*/true}));
EXPECT_EQ(Style.AlignConsecutiveDeclarations,
FormatStyle::AlignConsecutiveStyle(
{/*Enabled=*/false, /*AcrossEmptyLines=*/false,
/*AcrossComments=*/false, /*AlignCompound=*/false,
- /*AlignFunctionPointers=*/false,
/*AlignFunctionDeclarations=*/true,
+ /*AlignFunctionPointers=*/false,
/*PadOperators=*/false}));
verifyFormat("void foo() {\n"
" int myVar = 5;\n"
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
