https://github.com/gedare updated
https://github.com/llvm/llvm-project/pull/69340
>From 610d0b544d7927af93b6943078df033f154b74f8 Mon Sep 17 00:00:00 2001
From: Gedare Bloom <ged...@rtems.org>
Date: Thu, 9 Nov 2023 09:30:24 -0700
Subject: [PATCH 1/4] Revert "Revert "[clang-format] Fix align consecutive
declarations over function pointers""
This reverts commit 7bc1031c474ebb2216a5432273dafe4d1490fbce.
---
clang/lib/Format/WhitespaceManager.cpp | 2 +-
clang/unittests/Format/FormatTest.cpp | 10 ++++++++++
2 files changed, 11 insertions(+), 1 deletion(-)
diff --git a/clang/lib/Format/WhitespaceManager.cpp
b/clang/lib/Format/WhitespaceManager.cpp
index ff8b1e6e13a3f7..d4d66f0a9b2ab9 100644
--- a/clang/lib/Format/WhitespaceManager.cpp
+++ b/clang/lib/Format/WhitespaceManager.cpp
@@ -980,7 +980,7 @@ void WhitespaceManager::alignConsecutiveDeclarations() {
AlignTokens(
Style,
[](Change const &C) {
- if (C.Tok->is(TT_FunctionDeclarationName))
+ if (C.Tok->isOneOf(TT_FunctionDeclarationName, TT_FunctionTypeLParen))
return true;
if (C.Tok->isNot(TT_StartOfName))
return false;
diff --git a/clang/unittests/Format/FormatTest.cpp
b/clang/unittests/Format/FormatTest.cpp
index 80903e7630c807..19de60a5a4031d 100644
--- a/clang/unittests/Format/FormatTest.cpp
+++ b/clang/unittests/Format/FormatTest.cpp
@@ -2047,6 +2047,8 @@ TEST_F(FormatTest, SeparatePointerReferenceAlignment) {
"const unsigned int *d;\n"
"Const unsigned int &e;\n"
"const unsigned int &f;\n"
+ "int *f1(int *a, int &b, int &&c);\n"
+ "double *(*f2)(int *a, double &&b);\n"
"const unsigned &&g;\n"
"Const unsigned h;",
Style);
@@ -2092,6 +2094,8 @@ TEST_F(FormatTest, SeparatePointerReferenceAlignment) {
"const unsigned int* d;\n"
"Const unsigned int& e;\n"
"const unsigned int& f;\n"
+ "int* f1(int* a, int& b, int&& c);\n"
+ "double* (*f2)(int* a, double&& b);\n"
"const unsigned&& g;\n"
"Const unsigned h;",
Style);
@@ -2117,6 +2121,8 @@ TEST_F(FormatTest, SeparatePointerReferenceAlignment) {
"const unsigned int *d;\n"
"Const unsigned int& e;\n"
"const unsigned int& f;\n"
+ "int *f1(int *a, int& b, int&& c);\n"
+ "double *(*f2)(int *a, double&& b);\n"
"const unsigned g;\n"
"Const unsigned h;",
Style);
@@ -2157,6 +2163,8 @@ TEST_F(FormatTest, SeparatePointerReferenceAlignment) {
"const unsigned int* d;\n"
"Const unsigned int & e;\n"
"const unsigned int & f;\n"
+ "int* f1(int* a, int & b, int && c);\n"
+ "double* (*f2)(int* a, double && b);\n"
"const unsigned && g;\n"
"Const unsigned h;",
Style);
@@ -2182,6 +2190,8 @@ TEST_F(FormatTest, SeparatePointerReferenceAlignment) {
"const unsigned int * d;\n"
"Const unsigned int &e;\n"
"const unsigned int &f;\n"
+ "int * f1(int * a, int &b, int &&c);\n"
+ "double * (*f2)(int * a, double &&b);\n"
"const unsigned &&g;\n"
"Const unsigned h;",
Style);
>From bb386b5e912686fb292fb0de89e124fa54076aa7 Mon Sep 17 00:00:00 2001
From: Gedare Bloom <ged...@rtems.org>
Date: Tue, 17 Oct 2023 08:21:55 -0600
Subject: [PATCH 2/4] Split alignment of declarations around assignment
Function pointers are detected as a type of declaration using
FunctionTypeLParen. They are aligned based on rules for
AlignConsecutiveDeclarations. When a function pointer is on the
right-hand side of an assignment, the alignment of the function pointer
can result in excessive whitespace padding due to the ordering of
alignment, as the alignment processes a line from left-to-right and
first aligns the declarations before and after the assignment operator,
and then aligns the assignment operator. Injection of whitespace by
alignment of declarations after the equal sign followed by alignment
of the equal sign results in the excessive whitespace.
Fixes #68079.
---
clang/lib/Format/WhitespaceManager.cpp | 3 +++
clang/unittests/Format/FormatTest.cpp | 9 +++++++++
2 files changed, 12 insertions(+)
diff --git a/clang/lib/Format/WhitespaceManager.cpp
b/clang/lib/Format/WhitespaceManager.cpp
index d4d66f0a9b2ab9..294a87a6759212 100644
--- a/clang/lib/Format/WhitespaceManager.cpp
+++ b/clang/lib/Format/WhitespaceManager.cpp
@@ -980,6 +980,9 @@ void WhitespaceManager::alignConsecutiveDeclarations() {
AlignTokens(
Style,
[](Change const &C) {
+ for (FormatToken *Prev = C.Tok->Previous; Prev; Prev = Prev->Previous)
+ if (Prev->is(tok::equal))
+ return false;
if (C.Tok->isOneOf(TT_FunctionDeclarationName, TT_FunctionTypeLParen))
return true;
if (C.Tok->isNot(TT_StartOfName))
diff --git a/clang/unittests/Format/FormatTest.cpp
b/clang/unittests/Format/FormatTest.cpp
index 19de60a5a4031d..cb51cf28420827 100644
--- a/clang/unittests/Format/FormatTest.cpp
+++ b/clang/unittests/Format/FormatTest.cpp
@@ -18867,6 +18867,15 @@ TEST_F(FormatTest, AlignConsecutiveDeclarations) {
" \"bb\"};\n"
"int bbbbbbb = 0;",
Alignment);
+ // http://llvm.org/PR68079
+ verifyFormat("using Fn = int (A::*)();\n"
+ "using RFn = int (A::*)() &;\n"
+ "using RRFn = int (A::*)() &&;",
+ Alignment);
+ verifyFormat("using Fn = int (A::*)();\n"
+ "using RFn = int *(A::*)() &;\n"
+ "using RRFn = double (A::*)() &&;",
+ Alignment);
// PAS_Right
verifyFormat("void SomeFunction(int parameter = 0) {\n"
>From 1c89c6a704718c9cfa8b7b675b009a6412d57ec7 Mon Sep 17 00:00:00 2001
From: Gedare Bloom <ged...@rtems.org>
Date: Thu, 9 Nov 2023 12:54:38 -0700
Subject: [PATCH 3/4] fix whitespace
---
clang/unittests/Format/FormatTest.cpp | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/clang/unittests/Format/FormatTest.cpp
b/clang/unittests/Format/FormatTest.cpp
index cb51cf28420827..d21985cc545327 100644
--- a/clang/unittests/Format/FormatTest.cpp
+++ b/clang/unittests/Format/FormatTest.cpp
@@ -18872,8 +18872,8 @@ TEST_F(FormatTest, AlignConsecutiveDeclarations) {
"using RFn = int (A::*)() &;\n"
"using RRFn = int (A::*)() &&;",
Alignment);
- verifyFormat("using Fn = int (A::*)();\n"
- "using RFn = int *(A::*)() &;\n"
+ verifyFormat("using Fn = int (A::*)();\n"
+ "using RFn = int *(A::*)() &;\n"
"using RRFn = double (A::*)() &&;",
Alignment);
>From d7b59c3a2a28f92aabdef7909fd5b0d4e1f3dd59 Mon Sep 17 00:00:00 2001
From: Gedare Bloom <ged...@rtems.org>
Date: Tue, 19 Dec 2023 14:08:55 -0700
Subject: [PATCH 4/4] Make AlignFunctionPointers a sub option
---
clang/include/clang/Format/Format.h | 20 ++++++-
clang/lib/Format/Format.cpp | 35 ++++++++----
clang/lib/Format/WhitespaceManager.cpp | 14 +++--
clang/unittests/Format/ConfigParseTest.cpp | 66 ++++++++++++----------
clang/unittests/Format/FormatTest.cpp | 59 ++++++++++++++++++-
5 files changed, 144 insertions(+), 50 deletions(-)
diff --git a/clang/include/clang/Format/Format.h
b/clang/include/clang/Format/Format.h
index 3e9d1915badd87..a5cf1bc777f59a 100644
--- a/clang/include/clang/Format/Format.h
+++ b/clang/include/clang/Format/Format.h
@@ -225,6 +225,22 @@ struct FormatStyle {
/// bbb = 2;
/// \endcode
bool AlignCompound;
+ /// Only for ``AlignConsecutiveDeclarations''. Whether function pointers
+ /// are aligned.
+ /// \code
+ /// true:
+ /// unsigned i;
+ /// int &r;
+ /// int *p;
+ /// int *(f)();
+ ///
+ /// false:
+ /// unsigned i;
+ /// int &r;
+ /// int *p;
+ /// int *(f)();
+ /// \endcode
+ 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.
@@ -247,7 +263,9 @@ struct FormatStyle {
bool operator==(const AlignConsecutiveStyle &R) const {
return Enabled == R.Enabled && AcrossEmptyLines == R.AcrossEmptyLines &&
AcrossComments == R.AcrossComments &&
- AlignCompound == R.AlignCompound && PadOperators ==
R.PadOperators;
+ AlignCompound == R.AlignCompound &&
+ AlignFunctionPointers == R.AlignFunctionPointers &&
+ PadOperators == R.PadOperators;
}
bool operator!=(const AlignConsecutiveStyle &R) const {
return !(*this == R);
diff --git a/clang/lib/Format/Format.cpp b/clang/lib/Format/Format.cpp
index e1abcac5604a41..64278279fb5038 100644
--- a/clang/lib/Format/Format.cpp
+++ b/clang/lib/Format/Format.cpp
@@ -75,40 +75,49 @@ template <> struct
MappingTraits<FormatStyle::AlignConsecutiveStyle> {
FormatStyle::AlignConsecutiveStyle(
{/*Enabled=*/false, /*AcrossEmptyLines=*/false,
/*AcrossComments=*/false, /*AlignCompound=*/false,
+ /*AlignFunctionPointers=*/false,
/*PadOperators=*/true}));
IO.enumCase(Value, "Consecutive",
FormatStyle::AlignConsecutiveStyle(
{/*Enabled=*/true, /*AcrossEmptyLines=*/false,
/*AcrossComments=*/false, /*AlignCompound=*/false,
+ /*AlignFunctionPointers=*/false,
/*PadOperators=*/true}));
IO.enumCase(Value, "AcrossEmptyLines",
FormatStyle::AlignConsecutiveStyle(
{/*Enabled=*/true, /*AcrossEmptyLines=*/true,
/*AcrossComments=*/false, /*AlignCompound=*/false,
+ /*AlignFunctionPointers=*/false,
/*PadOperators=*/true}));
- IO.enumCase(Value, "AcrossComments",
- FormatStyle::AlignConsecutiveStyle({/*Enabled=*/true,
- /*AcrossEmptyLines=*/false,
- /*AcrossComments=*/true,
- /*AlignCompound=*/false,
- /*PadOperators=*/true}));
- IO.enumCase(Value, "AcrossEmptyLinesAndComments",
- FormatStyle::AlignConsecutiveStyle({/*Enabled=*/true,
- /*AcrossEmptyLines=*/true,
- /*AcrossComments=*/true,
- /*AlignCompound=*/false,
- /*PadOperators=*/true}));
+ IO.enumCase(
+ Value, "AcrossComments",
+ FormatStyle::AlignConsecutiveStyle({/*Enabled=*/true,
+ /*AcrossEmptyLines=*/false,
+ /*AcrossComments=*/true,
+ /*AlignCompound=*/false,
+ /*AlignFunctionPointers=*/false,
+ /*PadOperators=*/true}));
+ IO.enumCase(
+ Value, "AcrossEmptyLinesAndComments",
+ FormatStyle::AlignConsecutiveStyle({/*Enabled=*/true,
+ /*AcrossEmptyLines=*/true,
+ /*AcrossComments=*/true,
+ /*AlignCompound=*/false,
+ /*AlignFunctionPointers=*/false,
+ /*PadOperators=*/true}));
// For backward compatibility.
IO.enumCase(Value, "true",
FormatStyle::AlignConsecutiveStyle(
{/*Enabled=*/true, /*AcrossEmptyLines=*/false,
/*AcrossComments=*/false, /*AlignCompound=*/false,
+ /*AlignFunctionPointers=*/false,
/*PadOperators=*/true}));
IO.enumCase(Value, "false",
FormatStyle::AlignConsecutiveStyle(
{/*Enabled=*/false, /*AcrossEmptyLines=*/false,
/*AcrossComments=*/false, /*AlignCompound=*/false,
+ /*AlignFunctionPointers=*/false,
/*PadOperators=*/true}));
}
@@ -117,6 +126,7 @@ 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("PadOperators", Value.PadOperators);
}
};
@@ -1431,6 +1441,7 @@ FormatStyle getLLVMStyle(FormatStyle::LanguageKind
Language) {
LLVMStyle.AlignConsecutiveAssignments.AcrossEmptyLines = false;
LLVMStyle.AlignConsecutiveAssignments.AcrossComments = false;
LLVMStyle.AlignConsecutiveAssignments.AlignCompound = false;
+ LLVMStyle.AlignConsecutiveAssignments.AlignFunctionPointers = false;
LLVMStyle.AlignConsecutiveAssignments.PadOperators = true;
LLVMStyle.AlignConsecutiveBitFields = {};
LLVMStyle.AlignConsecutiveDeclarations = {};
diff --git a/clang/lib/Format/WhitespaceManager.cpp
b/clang/lib/Format/WhitespaceManager.cpp
index 294a87a6759212..0710a879f119b9 100644
--- a/clang/lib/Format/WhitespaceManager.cpp
+++ b/clang/lib/Format/WhitespaceManager.cpp
@@ -979,11 +979,15 @@ void WhitespaceManager::alignConsecutiveDeclarations() {
AlignTokens(
Style,
- [](Change const &C) {
- for (FormatToken *Prev = C.Tok->Previous; Prev; Prev = Prev->Previous)
- if (Prev->is(tok::equal))
- return false;
- if (C.Tok->isOneOf(TT_FunctionDeclarationName, TT_FunctionTypeLParen))
+ [&](Change const &C) {
+ if (Style.AlignConsecutiveDeclarations.AlignFunctionPointers) {
+ for (FormatToken *Prev = C.Tok->Previous; Prev; Prev =
Prev->Previous)
+ if (Prev->is(tok::equal))
+ return false;
+ if (C.Tok->is(TT_FunctionTypeLParen))
+ return true;
+ }
+ if (C.Tok->is(TT_FunctionDeclarationName))
return true;
if (C.Tok->isNot(TT_StartOfName))
return false;
diff --git a/clang/unittests/Format/ConfigParseTest.cpp
b/clang/unittests/Format/ConfigParseTest.cpp
index 3a6667dbe0eb15..dc5ee02b60bc95 100644
--- a/clang/unittests/Format/ConfigParseTest.cpp
+++ b/clang/unittests/Format/ConfigParseTest.cpp
@@ -288,37 +288,43 @@ TEST(ConfigParseTest, ParsesConfiguration) {
#define CHECK_ALIGN_CONSECUTIVE(FIELD)
\
do {
\
Style.FIELD.Enabled = true;
\
- CHECK_PARSE(#FIELD ": None", FIELD,
\
- FormatStyle::AlignConsecutiveStyle(
\
- {/*Enabled=*/false, /*AcrossEmptyLines=*/false,
\
- /*AcrossComments=*/false, /*AlignCompound=*/false,
\
- /*PadOperators=*/true}));
\
- CHECK_PARSE(#FIELD ": Consecutive", FIELD,
\
- FormatStyle::AlignConsecutiveStyle(
\
- {/*Enabled=*/true, /*AcrossEmptyLines=*/false,
\
- /*AcrossComments=*/false, /*AlignCompound=*/false,
\
- /*PadOperators=*/true}));
\
- CHECK_PARSE(#FIELD ": AcrossEmptyLines", FIELD,
\
- FormatStyle::AlignConsecutiveStyle(
\
- {/*Enabled=*/true, /*AcrossEmptyLines=*/true,
\
- /*AcrossComments=*/false, /*AlignCompound=*/false,
\
- /*PadOperators=*/true}));
\
- CHECK_PARSE(#FIELD ": AcrossEmptyLinesAndComments", FIELD,
\
- FormatStyle::AlignConsecutiveStyle(
\
- {/*Enabled=*/true, /*AcrossEmptyLines=*/true,
\
- /*AcrossComments=*/true, /*AlignCompound=*/false,
\
- /*PadOperators=*/true}));
\
+ CHECK_PARSE(
\
+ #FIELD ": None", FIELD,
\
+ FormatStyle::AlignConsecutiveStyle(
\
+ {/*Enabled=*/false, /*AcrossEmptyLines=*/false,
\
+ /*AcrossComments=*/false, /*AlignCompound=*/false,
\
+ /*AlignFunctionPointers=*/false, /*PadOperators=*/true}));
\
+ CHECK_PARSE(
\
+ #FIELD ": Consecutive", FIELD,
\
+ FormatStyle::AlignConsecutiveStyle(
\
+ {/*Enabled=*/true, /*AcrossEmptyLines=*/false,
\
+ /*AcrossComments=*/false, /*AlignCompound=*/false,
\
+ /*AlignFunctionPointers=*/false, /*PadOperators=*/true}));
\
+ CHECK_PARSE(
\
+ #FIELD ": AcrossEmptyLines", FIELD,
\
+ FormatStyle::AlignConsecutiveStyle(
\
+ {/*Enabled=*/true, /*AcrossEmptyLines=*/true,
\
+ /*AcrossComments=*/false, /*AlignCompound=*/false,
\
+ /*AlignFunctionPointers=*/false, /*PadOperators=*/true}));
\
+ CHECK_PARSE(
\
+ #FIELD ": AcrossEmptyLinesAndComments", FIELD,
\
+ FormatStyle::AlignConsecutiveStyle(
\
+ {/*Enabled=*/true, /*AcrossEmptyLines=*/true,
\
+ /*AcrossComments=*/true, /*AlignCompound=*/false,
\
+ /*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,
\
- /*PadOperators=*/true}));
\
- CHECK_PARSE(#FIELD ": true", FIELD,
\
- FormatStyle::AlignConsecutiveStyle(
\
- {/*Enabled=*/true, /*AcrossEmptyLines=*/false,
\
- /*AcrossComments=*/false, /*AlignCompound=*/false,
\
- /*PadOperators=*/true}));
\
+ CHECK_PARSE(
\
+ #FIELD ": false", FIELD,
\
+ FormatStyle::AlignConsecutiveStyle(
\
+ {/*Enabled=*/false, /*AcrossEmptyLines=*/false,
\
+ /*AcrossComments=*/false, /*AlignCompound=*/false,
\
+ /*AlignFunctionPointers=*/false, /*PadOperators=*/true}));
\
+ CHECK_PARSE(
\
+ #FIELD ": true", FIELD,
\
+ FormatStyle::AlignConsecutiveStyle(
\
+ {/*Enabled=*/true, /*AcrossEmptyLines=*/false,
\
+ /*AcrossComments=*/false, /*AlignCompound=*/false,
\
+ /*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 d21985cc545327..c91e1adfa74e96 100644
--- a/clang/unittests/Format/FormatTest.cpp
+++ b/clang/unittests/Format/FormatTest.cpp
@@ -2043,6 +2043,7 @@ TEST_F(FormatTest, SeparatePointerReferenceAlignment) {
Style);
Style.AlignConsecutiveDeclarations.Enabled = true;
+ Style.AlignConsecutiveDeclarations.AlignFunctionPointers = true;
verifyFormat("Const unsigned int *c;\n"
"const unsigned int *d;\n"
"Const unsigned int &e;\n"
@@ -2052,6 +2053,16 @@ TEST_F(FormatTest, SeparatePointerReferenceAlignment) {
"const unsigned &&g;\n"
"Const unsigned h;",
Style);
+ Style.AlignConsecutiveDeclarations.AlignFunctionPointers = false;
+ verifyFormat("Const unsigned int *c;\n"
+ "const unsigned int *d;\n"
+ "Const unsigned int &e;\n"
+ "const unsigned int &f;\n"
+ "int *f1(int *a, int &b, int &&c);\n"
+ "double *(*f2)(int *a, double &&b);\n"
+ "const unsigned &&g;\n"
+ "Const unsigned h;",
+ Style);
Style.PointerAlignment = FormatStyle::PAS_Left;
Style.ReferenceAlignment = FormatStyle::RAS_Pointer;
@@ -2090,6 +2101,7 @@ TEST_F(FormatTest, SeparatePointerReferenceAlignment) {
Style);
Style.AlignConsecutiveDeclarations.Enabled = true;
+ Style.AlignConsecutiveDeclarations.AlignFunctionPointers = true;
verifyFormat("Const unsigned int* c;\n"
"const unsigned int* d;\n"
"Const unsigned int& e;\n"
@@ -2099,6 +2111,16 @@ TEST_F(FormatTest, SeparatePointerReferenceAlignment) {
"const unsigned&& g;\n"
"Const unsigned h;",
Style);
+ Style.AlignConsecutiveDeclarations.AlignFunctionPointers = false;
+ verifyFormat("Const unsigned int* c;\n"
+ "const unsigned int* d;\n"
+ "Const unsigned int& e;\n"
+ "const unsigned int& f;\n"
+ "int* f1(int* a, int& b, int&& c);\n"
+ "double* (*f2)(int* a, double&& b);\n"
+ "const unsigned&& g;\n"
+ "Const unsigned h;",
+ Style);
Style.PointerAlignment = FormatStyle::PAS_Right;
Style.ReferenceAlignment = FormatStyle::RAS_Left;
@@ -2117,15 +2139,26 @@ TEST_F(FormatTest, SeparatePointerReferenceAlignment) {
verifyFormat("for (int a = 0, b++; const Foo *c : {1, 2, 3})", Style);
Style.AlignConsecutiveDeclarations.Enabled = true;
+ Style.AlignConsecutiveDeclarations.AlignFunctionPointers = true;
verifyFormat("Const unsigned int *c;\n"
"const unsigned int *d;\n"
"Const unsigned int& e;\n"
"const unsigned int& f;\n"
"int *f1(int *a, int& b, int&& c);\n"
"double *(*f2)(int *a, double&& b);\n"
- "const unsigned g;\n"
+ "const unsigned&& g;\n"
"Const unsigned h;",
Style);
+ Style.AlignConsecutiveDeclarations.AlignFunctionPointers = false;
+ verifyFormat("Const unsigned int *c;\n"
+ "const unsigned int *d;\n"
+ "Const unsigned int& e;\n"
+ "const unsigned int& f;\n"
+ "int *f1(int *a, int& b, int&& c);\n"
+ "double *(*f2)(int *a, double&& b);\n"
+ "const unsigned&& g;\n"
+ "Const unsigned h;",
+ Style);
Style.PointerAlignment = FormatStyle::PAS_Left;
Style.ReferenceAlignment = FormatStyle::RAS_Middle;
@@ -2159,6 +2192,7 @@ TEST_F(FormatTest, SeparatePointerReferenceAlignment) {
Style);
Style.AlignConsecutiveDeclarations.Enabled = true;
+ Style.AlignConsecutiveDeclarations.AlignFunctionPointers = true;
verifyFormat("Const unsigned int* c;\n"
"const unsigned int* d;\n"
"Const unsigned int & e;\n"
@@ -2168,6 +2202,16 @@ TEST_F(FormatTest, SeparatePointerReferenceAlignment) {
"const unsigned && g;\n"
"Const unsigned h;",
Style);
+ Style.AlignConsecutiveDeclarations.AlignFunctionPointers = false;
+ verifyFormat("Const unsigned int* c;\n"
+ "const unsigned int* d;\n"
+ "Const unsigned int & e;\n"
+ "const unsigned int & f;\n"
+ "int* f1(int* a, int & b, int && c);\n"
+ "double* (*f2)(int* a, double && b);\n"
+ "const unsigned && g;\n"
+ "Const unsigned h;",
+ Style);
Style.PointerAlignment = FormatStyle::PAS_Middle;
Style.ReferenceAlignment = FormatStyle::RAS_Right;
@@ -2186,6 +2230,7 @@ TEST_F(FormatTest, SeparatePointerReferenceAlignment) {
verifyFormat("for (int a = 0, b++; const Foo * c : {1, 2, 3})", Style);
Style.AlignConsecutiveDeclarations.Enabled = true;
+ Style.AlignConsecutiveDeclarations.AlignFunctionPointers = true;
verifyFormat("Const unsigned int * c;\n"
"const unsigned int * d;\n"
"Const unsigned int &e;\n"
@@ -2195,6 +2240,16 @@ TEST_F(FormatTest, SeparatePointerReferenceAlignment) {
"const unsigned &&g;\n"
"Const unsigned h;",
Style);
+ Style.AlignConsecutiveDeclarations.AlignFunctionPointers = false;
+ verifyFormat("Const unsigned int * c;\n"
+ "const unsigned int * d;\n"
+ "Const unsigned int &e;\n"
+ "const unsigned int &f;\n"
+ "int * f1(int * a, int &b, int &&c);\n"
+ "double * (*f2)(int * a, double &&b);\n"
+ "const unsigned &&g;\n"
+ "Const unsigned h;",
+ Style);
// FIXME: we don't handle this yet, so output may be arbitrary until it's
// specifically handled
@@ -19528,7 +19583,7 @@ TEST_F(FormatTest, AlignWithLineBreaks) {
FormatStyle::AlignConsecutiveStyle(
{/*Enabled=*/false, /*AcrossEmptyLines=*/false,
/*AcrossComments=*/false, /*AlignCompound=*/false,
- /*PadOperators=*/true}));
+ /*AlignFunctionPointers=*/false, /*PadOperators=*/true}));
EXPECT_EQ(Style.AlignConsecutiveDeclarations,
FormatStyle::AlignConsecutiveStyle({}));
verifyFormat("void foo() {\n"
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
