tinloaf created this revision.
tinloaf added reviewers: MyDeveloperDay, djasper.
tinloaf requested review of this revision.
Herald added a project: clang.
Herald added a subscriber: cfe-commits.
Currently, empty lines and comments break alignment of assignments on
consecutive
lines. This makes the AlignConsecutiveAssignments option an enum that allows
controlling
whether empty lines or empty lines and comments should be ignored when aligning
assignments.
Repository:
rG LLVM Github Monorepo
https://reviews.llvm.org/D93985
Files:
clang/docs/ClangFormatStyleOptions.rst
clang/include/clang/Format/Format.h
clang/lib/Format/Format.cpp
clang/lib/Format/WhitespaceManager.cpp
clang/unittests/Format/FormatTest.cpp
Index: clang/unittests/Format/FormatTest.cpp
===================================================================
--- clang/unittests/Format/FormatTest.cpp
+++ clang/unittests/Format/FormatTest.cpp
@@ -11330,7 +11330,7 @@
"*/\n"
"}",
Tab));
- Tab.AlignConsecutiveAssignments = true;
+ Tab.AlignConsecutiveAssignments = FormatStyle::ACA_Consecutive;
Tab.AlignConsecutiveDeclarations = true;
Tab.TabWidth = 4;
Tab.IndentWidth = 4;
@@ -11569,7 +11569,7 @@
"*/\n"
"}",
Tab));
- Tab.AlignConsecutiveAssignments = true;
+ Tab.AlignConsecutiveAssignments = FormatStyle::ACA_Consecutive;
Tab.AlignConsecutiveDeclarations = true;
Tab.TabWidth = 4;
Tab.IndentWidth = 4;
@@ -12271,7 +12271,7 @@
TEST_F(FormatTest, AlignConsecutiveMacros) {
FormatStyle Style = getLLVMStyle();
- Style.AlignConsecutiveAssignments = true;
+ Style.AlignConsecutiveAssignments = FormatStyle::ACA_Consecutive;
Style.AlignConsecutiveDeclarations = true;
Style.AlignConsecutiveMacros = false;
@@ -12364,10 +12364,374 @@
Style);
}
+TEST_F(FormatTest, AlignConsecutiveAssignmentsAcrossEmptyLines) {
+ FormatStyle Alignment = getLLVMStyle();
+ Alignment.AlignConsecutiveMacros = true;
+ Alignment.AlignConsecutiveAssignments = FormatStyle::ACA_AcrossEmptyLines;
+
+ Alignment.MaxEmptyLinesToKeep = 10;
+ /* Test alignment across empty lines */
+ EXPECT_EQ("int a = 5;\n"
+ "\n"
+ "int oneTwoThree = 123;",
+ format("int a = 5;\n"
+ "\n"
+ "int oneTwoThree= 123;",
+ Alignment));
+ EXPECT_EQ("int a = 5;\n"
+ "int one = 1;\n"
+ "\n"
+ "int oneTwoThree = 123;",
+ format("int a = 5;\n"
+ "int one = 1;\n"
+ "\n"
+ "int oneTwoThree = 123;",
+ Alignment));
+ EXPECT_EQ("int a = 5;\n"
+ "int one = 1;\n"
+ "\n"
+ "int oneTwoThree = 123;\n"
+ "int oneTwo = 12;",
+ format("int a = 5;\n"
+ "int one = 1;\n"
+ "\n"
+ "int oneTwoThree = 123;\n"
+ "int oneTwo = 12;",
+ Alignment));
+
+ /* Test across comments */
+ EXPECT_EQ("int a = 5;\n"
+ "/* block comment */\n"
+ "int oneTwoThree = 123;",
+ format("int a = 5;\n"
+ "/* block comment */\n"
+ "int oneTwoThree=123;",
+ Alignment));
+
+ EXPECT_EQ("int a = 5;\n"
+ "// line comment\n"
+ "int oneTwoThree = 123;",
+ format("int a = 5;\n"
+ "// line comment\n"
+ "int oneTwoThree=123;",
+ Alignment));
+
+ /* Test across comments and newlines */
+ EXPECT_EQ("int a = 5;\n"
+ "\n"
+ "/* block comment */\n"
+ "int oneTwoThree = 123;",
+ format("int a = 5;\n"
+ "\n"
+ "/* block comment */\n"
+ "int oneTwoThree=123;",
+ Alignment));
+
+ EXPECT_EQ("int a = 5;\n"
+ "\n"
+ "// line comment\n"
+ "int oneTwoThree = 123;",
+ format("int a = 5;\n"
+ "\n"
+ "// line comment\n"
+ "int oneTwoThree=123;",
+ Alignment));
+}
+
+TEST_F(FormatTest, AlignConsecutiveAssignmentsAcrossComments) {
+ FormatStyle Alignment = getLLVMStyle();
+ Alignment.AlignConsecutiveMacros = true;
+ Alignment.AlignConsecutiveAssignments = FormatStyle::ACA_AcrossComments;
+ verifyFormat("int a = 5;\n"
+ "int oneTwoThree = 123;",
+ Alignment);
+ verifyFormat("int a = method();\n"
+ "int oneTwoThree = 133;",
+ Alignment);
+ verifyFormat("a &= 5;\n"
+ "bcd *= 5;\n"
+ "ghtyf += 5;\n"
+ "dvfvdb -= 5;\n"
+ "a /= 5;\n"
+ "vdsvsv %= 5;\n"
+ "sfdbddfbdfbb ^= 5;\n"
+ "dvsdsv |= 5;\n"
+ "int dsvvdvsdvvv = 123;",
+ Alignment);
+ verifyFormat("int i = 1, j = 10;\n"
+ "something = 2000;",
+ Alignment);
+ verifyFormat("something = 2000;\n"
+ "int i = 1, j = 10;\n",
+ Alignment);
+ verifyFormat("something = 2000;\n"
+ "another = 911;\n"
+ "int i = 1, j = 10;\n"
+ "oneMore = 1;\n"
+ "i = 2;",
+ Alignment);
+ verifyFormat("int a = 5;\n"
+ "int one = 1;\n"
+ "method();\n"
+ "int oneTwoThree = 123;\n"
+ "int oneTwo = 12;",
+ Alignment);
+ verifyFormat("int oneTwoThree = 123;\n"
+ "int oneTwo = 12;\n"
+ "method();\n",
+ Alignment);
+ verifyFormat("int oneTwoThree = 123; // comment\n"
+ "int oneTwo = 12; // comment",
+ Alignment);
+
+ // Bug 25167
+ /* Uncomment when fixed
+ verifyFormat("#if A\n"
+ "#else\n"
+ "int aaaaaaaa = 12;\n"
+ "#endif\n"
+ "#if B\n"
+ "#else\n"
+ "int a = 12;\n"
+ "#endif\n",
+ Alignment);
+ verifyFormat("enum foo {\n"
+ "#if A\n"
+ "#else\n"
+ " aaaaaaaa = 12;\n"
+ "#endif\n"
+ "#if B\n"
+ "#else\n"
+ " a = 12;\n"
+ "#endif\n"
+ "};\n",
+ Alignment);
+ */
+
+ Alignment.MaxEmptyLinesToKeep = 10;
+ /* Test alignment across empty lines */
+ EXPECT_EQ("int a = 5;\n"
+ "\n"
+ "int oneTwoThree = 123;",
+ format("int a = 5;\n"
+ "\n"
+ "int oneTwoThree= 123;",
+ Alignment));
+ EXPECT_EQ("int a = 5;\n"
+ "int one = 1;\n"
+ "\n"
+ "int oneTwoThree = 123;",
+ format("int a = 5;\n"
+ "int one = 1;\n"
+ "\n"
+ "int oneTwoThree = 123;",
+ Alignment));
+ EXPECT_EQ("int a = 5;\n"
+ "int one = 1;\n"
+ "\n"
+ "int oneTwoThree = 123;\n"
+ "int oneTwo = 12;",
+ format("int a = 5;\n"
+ "int one = 1;\n"
+ "\n"
+ "int oneTwoThree = 123;\n"
+ "int oneTwo = 12;",
+ Alignment));
+
+ /* Test across comments */
+ EXPECT_EQ("int a = 5;\n"
+ "/* block comment */\n"
+ "int oneTwoThree = 123;",
+ format("int a = 5;\n"
+ "/* block comment */\n"
+ "int oneTwoThree=123;",
+ Alignment));
+
+ EXPECT_EQ("int a = 5;\n"
+ "// line comment\n"
+ "int oneTwoThree = 123;",
+ format("int a = 5;\n"
+ "// line comment\n"
+ "int oneTwoThree=123;",
+ Alignment));
+
+ /* Test across comments and newlines */
+ EXPECT_EQ("int a = 5;\n"
+ "\n"
+ "/* block comment */\n"
+ "int oneTwoThree = 123;",
+ format("int a = 5;\n"
+ "\n"
+ "/* block comment */\n"
+ "int oneTwoThree=123;",
+ Alignment));
+
+ EXPECT_EQ("int a = 5;\n"
+ "\n"
+ "// line comment\n"
+ "int oneTwoThree = 123;",
+ format("int a = 5;\n"
+ "\n"
+ "// line comment\n"
+ "int oneTwoThree=123;",
+ Alignment));
+
+ EXPECT_EQ("int a = 5;\n"
+ "\n"
+ "/* block comment */\n"
+ "\n"
+ "\n"
+ "\n"
+ "int oneTwoThree = 123;",
+ format("int a = 5;\n"
+ "\n"
+ "/* block comment */\n"
+ "\n"
+ "\n"
+ "\n"
+ "int oneTwoThree=123;",
+ Alignment));
+
+ EXPECT_EQ("int a = 5;\n"
+ "\n"
+ "// line comment\n"
+ "\n"
+ "\n"
+ "\n"
+ "int oneTwoThree = 123;",
+ format("int a = 5;\n"
+ "\n"
+ "// line comment\n"
+ "\n"
+ "\n"
+ "\n"
+ "int oneTwoThree=123;",
+ Alignment));
+
+ Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign;
+ verifyFormat("#define A \\\n"
+ " int aaaa = 12; \\\n"
+ " int b = 23; \\\n"
+ " int ccc = 234; \\\n"
+ " int dddddddddd = 2345;",
+ Alignment);
+ Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left;
+ verifyFormat("#define A \\\n"
+ " int aaaa = 12; \\\n"
+ " int b = 23; \\\n"
+ " int ccc = 234; \\\n"
+ " int dddddddddd = 2345;",
+ Alignment);
+ Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right;
+ verifyFormat("#define A "
+ " \\\n"
+ " int aaaa = 12; "
+ " \\\n"
+ " int b = 23; "
+ " \\\n"
+ " int ccc = 234; "
+ " \\\n"
+ " int dddddddddd = 2345;",
+ Alignment);
+ verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int "
+ "k = 4, int l = 5,\n"
+ " int m = 6) {\n"
+ " int j = 10;\n"
+ " otherThing = 1;\n"
+ "}",
+ Alignment);
+ verifyFormat("void SomeFunction(int parameter = 0) {\n"
+ " int i = 1;\n"
+ " int j = 2;\n"
+ " int big = 10000;\n"
+ "}",
+ Alignment);
+ verifyFormat("class C {\n"
+ "public:\n"
+ " int i = 1;\n"
+ " virtual void f() = 0;\n"
+ "};",
+ Alignment);
+ verifyFormat("int i = 1;\n"
+ "if (SomeType t = getSomething()) {\n"
+ "}\n"
+ "int j = 2;\n"
+ "int big = 10000;",
+ Alignment);
+ verifyFormat("int j = 7;\n"
+ "for (int k = 0; k < N; ++k) {\n"
+ "}\n"
+ "int j = 2;\n"
+ "int big = 10000;\n"
+ "}",
+ Alignment);
+ Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
+ verifyFormat("int i = 1;\n"
+ "LooooooooooongType loooooooooooooooooooooongVariable\n"
+ " = someLooooooooooooooooongFunction();\n"
+ "int j = 2;",
+ Alignment);
+ Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
+ verifyFormat("int i = 1;\n"
+ "LooooooooooongType loooooooooooooooooooooongVariable =\n"
+ " someLooooooooooooooooongFunction();\n"
+ "int j = 2;",
+ Alignment);
+
+ verifyFormat("auto lambda = []() {\n"
+ " auto i = 0;\n"
+ " return 0;\n"
+ "};\n"
+ "int i = 0;\n"
+ "auto v = type{\n"
+ " i = 1, //\n"
+ " (i = 2), //\n"
+ " i = 3 //\n"
+ "};",
+ Alignment);
+
+ verifyFormat(
+ "int i = 1;\n"
+ "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n"
+ " loooooooooooooooooooooongParameterB);\n"
+ "int j = 2;",
+ Alignment);
+
+ verifyFormat("template <typename T, typename T_0 = very_long_type_name_0,\n"
+ " typename B = very_long_type_name_1,\n"
+ " typename T_2 = very_long_type_name_2>\n"
+ "auto foo() {}\n",
+ Alignment);
+ verifyFormat("int a, b = 1;\n"
+ "int c = 2;\n"
+ "int dd = 3;\n",
+ Alignment);
+ verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n"
+ "float b[1][] = {{3.f}};\n",
+ Alignment);
+ verifyFormat("for (int i = 0; i < 1; i++)\n"
+ " int x = 1;\n",
+ Alignment);
+ verifyFormat("for (i = 0; i < 1; i++)\n"
+ " x = 1;\n"
+ "y = 1;\n",
+ Alignment);
+
+ Alignment.ReflowComments = true;
+ Alignment.ColumnLimit = 50;
+ EXPECT_EQ("int x = 0;\n"
+ "int yy = 1; /// specificlennospace\n"
+ "int zzz = 2;\n",
+ format("int x = 0;\n"
+ "int yy = 1; ///specificlennospace\n"
+ "int zzz = 2;\n",
+ Alignment));
+}
+
TEST_F(FormatTest, AlignConsecutiveAssignments) {
FormatStyle Alignment = getLLVMStyle();
Alignment.AlignConsecutiveMacros = true;
- Alignment.AlignConsecutiveAssignments = false;
+ Alignment.AlignConsecutiveAssignments = FormatStyle::ACA_None;
verifyFormat("int a = 5;\n"
"int oneTwoThree = 123;",
Alignment);
@@ -12375,7 +12739,7 @@
"int oneTwoThree = 123;",
Alignment);
- Alignment.AlignConsecutiveAssignments = true;
+ Alignment.AlignConsecutiveAssignments = FormatStyle::ACA_Consecutive;
verifyFormat("int a = 5;\n"
"int oneTwoThree = 123;",
Alignment);
@@ -12614,7 +12978,7 @@
"int oneTwoThree : 23 = 0;",
Alignment);
- Alignment.AlignConsecutiveAssignments = true;
+ Alignment.AlignConsecutiveAssignments = FormatStyle::ACA_Consecutive;
verifyFormat("int const a : 5 = 1;\n"
"int oneTwoThree : 23 = 0;",
Alignment);
@@ -12754,7 +13118,7 @@
verifyFormat("int a(int x, void (*fp)(int y));\n"
"double b();",
Alignment);
- Alignment.AlignConsecutiveAssignments = true;
+ Alignment.AlignConsecutiveAssignments = FormatStyle::ACA_Consecutive;
// Ensure recursive alignment is broken by function braces, so that the
// "a = 1" does not align with subsequent assignments inside the function
// body.
@@ -12817,7 +13181,7 @@
"int ll=10000;\n"
"}",
Alignment));
- Alignment.AlignConsecutiveAssignments = false;
+ Alignment.AlignConsecutiveAssignments = FormatStyle::ACA_None;
Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign;
verifyFormat("#define A \\\n"
" int aaaa = 12; \\\n"
@@ -12886,7 +13250,7 @@
"int j = 2;",
Alignment);
- Alignment.AlignConsecutiveAssignments = true;
+ Alignment.AlignConsecutiveAssignments = FormatStyle::ACA_Consecutive;
verifyFormat("auto lambda = []() {\n"
" auto ii = 0;\n"
" float j = 0;\n"
@@ -12900,7 +13264,7 @@
" i = 3 //\n"
"};",
Alignment);
- Alignment.AlignConsecutiveAssignments = false;
+ Alignment.AlignConsecutiveAssignments = FormatStyle::ACA_None;
verifyFormat(
"int i = 1;\n"
@@ -12913,7 +13277,7 @@
// We expect declarations and assignments to align, as long as it doesn't
// exceed the column limit, starting a new alignment sequence whenever it
// happens.
- Alignment.AlignConsecutiveAssignments = true;
+ Alignment.AlignConsecutiveAssignments = FormatStyle::ACA_Consecutive;
Alignment.ColumnLimit = 30;
verifyFormat("float ii = 1;\n"
"unsigned j = 2;\n"
@@ -12923,7 +13287,7 @@
"int myvar = 1;",
Alignment);
Alignment.ColumnLimit = 80;
- Alignment.AlignConsecutiveAssignments = false;
+ Alignment.AlignConsecutiveAssignments = FormatStyle::ACA_None;
verifyFormat(
"template <typename LongTemplate, typename VeryLongTemplateTypeName,\n"
@@ -12937,7 +13301,7 @@
verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n"
"float b[1][] = {{3.f}};\n",
Alignment);
- Alignment.AlignConsecutiveAssignments = true;
+ Alignment.AlignConsecutiveAssignments = FormatStyle::ACA_Consecutive;
verifyFormat("float a, b = 1;\n"
"int c = 2;\n"
"int dd = 3;\n",
@@ -12945,7 +13309,7 @@
verifyFormat("int aa = ((1 > 2) ? 3 : 4);\n"
"float b[1][] = {{3.f}};\n",
Alignment);
- Alignment.AlignConsecutiveAssignments = false;
+ Alignment.AlignConsecutiveAssignments = FormatStyle::ACA_None;
Alignment.ColumnLimit = 30;
Alignment.BinPackParameters = false;
@@ -14123,7 +14487,6 @@
FormatStyle Style = {};
Style.Language = FormatStyle::LK_Cpp;
CHECK_PARSE_BOOL(AlignTrailingComments);
- CHECK_PARSE_BOOL(AlignConsecutiveAssignments);
CHECK_PARSE_BOOL(AlignConsecutiveBitFields);
CHECK_PARSE_BOOL(AlignConsecutiveDeclarations);
CHECK_PARSE_BOOL(AlignConsecutiveMacros);
@@ -14221,6 +14584,21 @@
CHECK_PARSE("ContinuationIndentWidth: 11", ContinuationIndentWidth, 11u);
CHECK_PARSE("CommentPragmas: '// abc$'", CommentPragmas, "// abc$");
+ Style.AlignConsecutiveAssignments = FormatStyle::ACA_Consecutive;
+ CHECK_PARSE("AlignConsecutiveAssignments: None", AlignConsecutiveAssignments,
+ FormatStyle::ACA_None);
+ CHECK_PARSE("AlignConsecutiveAssignments: Consecutive",
+ AlignConsecutiveAssignments, FormatStyle::ACA_Consecutive);
+ CHECK_PARSE("AlignConsecutiveAssignments: AcrossEmptyLines",
+ AlignConsecutiveAssignments, FormatStyle::ACA_AcrossEmptyLines);
+ CHECK_PARSE("AlignConsecutiveAssignments: AcrossComments",
+ AlignConsecutiveAssignments, FormatStyle::ACA_AcrossComments);
+ // For backwards compability, false / true should still parse
+ CHECK_PARSE("AlignConsecutiveAssignments: false", AlignConsecutiveAssignments,
+ FormatStyle::ACA_None);
+ CHECK_PARSE("AlignConsecutiveAssignments: true", AlignConsecutiveAssignments,
+ FormatStyle::ACA_Consecutive);
+
Style.PointerAlignment = FormatStyle::PAS_Middle;
CHECK_PARSE("PointerAlignment: Left", PointerAlignment,
FormatStyle::PAS_Left);
@@ -17144,7 +17522,7 @@
format("FOO(String-ized&Messy+But,: :\n"
" Still=Intentional);",
Style));
- Style.AlignConsecutiveAssignments = true;
+ Style.AlignConsecutiveAssignments = FormatStyle::ACA_Consecutive;
EXPECT_EQ("FOO(String-ized=&Messy+But,: :\n"
" Still=Intentional);",
format("FOO(String-ized=&Messy+But,: :\n"
Index: clang/lib/Format/WhitespaceManager.cpp
===================================================================
--- clang/lib/Format/WhitespaceManager.cpp
+++ clang/lib/Format/WhitespaceManager.cpp
@@ -13,6 +13,7 @@
#include "WhitespaceManager.h"
#include "llvm/ADT/STLExtras.h"
+#include <iostream>
namespace clang {
namespace format {
@@ -363,7 +364,8 @@
template <typename F>
static unsigned AlignTokens(const FormatStyle &Style, F &&Matches,
SmallVector<WhitespaceManager::Change, 16> &Changes,
- unsigned StartAt) {
+ unsigned StartAt, bool AcrossEmpty = false,
+ bool AcrossComments = false) {
unsigned MinColumn = 0;
unsigned MaxColumn = UINT_MAX;
@@ -386,6 +388,9 @@
// Whether a matching token has been found on the current line.
bool FoundMatchOnLine = false;
+ // Whether the current line consists purely of comments
+ bool LineIsComment = true;
+
// Aligns a sequence of matching tokens, on the MinColumn column.
//
// Sequences start from the first matching token to align, and end at the
@@ -411,19 +416,27 @@
if (Changes[i].NewlinesBefore != 0) {
CommasBeforeMatch = 0;
EndOfSequence = i;
- // If there is a blank line, or if the last line didn't contain any
+ // If there is a blank line (and we don't align across empty lines),
+ // or if the last line didn't contain any
// matching token, the sequence ends here.
- if (Changes[i].NewlinesBefore > 1 || !FoundMatchOnLine)
+ if (((Changes[i].NewlinesBefore > 1) && (!AcrossEmpty)) ||
+ (!FoundMatchOnLine && (!(LineIsComment && AcrossComments))))
AlignCurrentSequence();
FoundMatchOnLine = false;
+ LineIsComment = true;
+ }
+
+ if (!Changes[i].Tok->is(tok::comment)) {
+ LineIsComment = false;
}
if (Changes[i].Tok->is(tok::comma)) {
++CommasBeforeMatch;
} else if (Changes[i].indentAndNestingLevel() > IndentAndNestingLevel) {
// Call AlignTokens recursively, skipping over this scope block.
- unsigned StoppedAt = AlignTokens(Style, Matches, Changes, i);
+ unsigned StoppedAt =
+ AlignTokens(Style, Matches, Changes, i, AcrossEmpty, AcrossComments);
i = StoppedAt - 1;
continue;
}
@@ -597,23 +610,25 @@
}
void WhitespaceManager::alignConsecutiveAssignments() {
- if (!Style.AlignConsecutiveAssignments)
+ if (Style.AlignConsecutiveAssignments == FormatStyle::ACA_None)
return;
- AlignTokens(
- Style,
- [&](const Change &C) {
- // Do not align on equal signs that are first on a line.
- if (C.NewlinesBefore > 0)
- return false;
-
- // Do not align on equal signs that are last on a line.
- if (&C != &Changes.back() && (&C + 1)->NewlinesBefore > 0)
- return false;
-
- return C.Tok->is(tok::equal);
- },
- Changes, /*StartAt=*/0);
+ AlignTokens(Style,
+ [&](const Change &C) {
+ // Do not align on equal signs that are first on a line.
+ if (C.NewlinesBefore > 0)
+ return false;
+
+ // Do not align on equal signs that are last on a line.
+ if (&C != &Changes.back() && (&C + 1)->NewlinesBefore > 0)
+ return false;
+
+ return C.Tok->is(tok::equal);
+ },
+ Changes, /*StartAt=*/0,
+ Style.AlignConsecutiveAssignments != FormatStyle::ACA_Consecutive,
+ Style.AlignConsecutiveAssignments ==
+ FormatStyle::ACA_AcrossComments);
}
void WhitespaceManager::alignConsecutiveBitFields() {
Index: clang/lib/Format/Format.cpp
===================================================================
--- clang/lib/Format/Format.cpp
+++ clang/lib/Format/Format.cpp
@@ -128,6 +128,19 @@
}
};
+template <>
+struct ScalarEnumerationTraits<FormatStyle::AlignConsecutiveAssignmentsStyle> {
+ static void
+ enumeration(IO &IO, FormatStyle::AlignConsecutiveAssignmentsStyle &Value) {
+ IO.enumCase(Value, "None", FormatStyle::ACA_None);
+ IO.enumCase(Value, "false", FormatStyle::ACA_None);
+ IO.enumCase(Value, "Consecutive", FormatStyle::ACA_Consecutive);
+ IO.enumCase(Value, "true", FormatStyle::ACA_Consecutive);
+ IO.enumCase(Value, "AcrossEmptyLines", FormatStyle::ACA_AcrossEmptyLines);
+ IO.enumCase(Value, "AcrossComments", FormatStyle::ACA_AcrossComments);
+ }
+};
+
template <> struct ScalarEnumerationTraits<FormatStyle::ShortIfStyle> {
static void enumeration(IO &IO, FormatStyle::ShortIfStyle &Value) {
IO.enumCase(Value, "Never", FormatStyle::SIS_Never);
@@ -854,7 +867,7 @@
LLVMStyle.AlignAfterOpenBracket = FormatStyle::BAS_Align;
LLVMStyle.AlignOperands = FormatStyle::OAS_Align;
LLVMStyle.AlignTrailingComments = true;
- LLVMStyle.AlignConsecutiveAssignments = false;
+ LLVMStyle.AlignConsecutiveAssignments = FormatStyle::ACA_None;
LLVMStyle.AlignConsecutiveBitFields = false;
LLVMStyle.AlignConsecutiveDeclarations = false;
LLVMStyle.AlignConsecutiveMacros = false;
Index: clang/include/clang/Format/Format.h
===================================================================
--- clang/include/clang/Format/Format.h
+++ clang/include/clang/Format/Format.h
@@ -106,7 +106,42 @@
/// int b = 23;
/// int ccc = 23;
/// \endcode
- bool AlignConsecutiveAssignments;
+
+ /// Styles for alignment of consecutive assignments
+ enum AlignConsecutiveAssignmentsStyle {
+ /// Do not align consecutive assignments.
+ ACA_None,
+ /// Align assignments on consecutive lines. This will result in
+ /// formattings like
+ /// \code
+ /// int aaaa = 12;
+ /// int b = 23;
+ /// int ccc = 23;
+ /// \endcode
+ ACA_Consecutive,
+ /// Same as ACA_Consecutive, but alignment also spans over empty
+ /// lines, e.g.
+ /// \code
+ /// int aaaa = 12;
+ /// int b = 23;
+ ///
+ /// int ccc = 23;
+ /// \endcode
+ ACA_AcrossEmptyLines,
+ /// Same as ACA_Consecutive, but alignment also spans over empty
+ /// lines and lines containing only comments, e.g.
+ /// \code
+ /// int aaaa = 12;
+ /// int b = 23;
+ ///
+ /// /* This is a comment */
+ /// int ccc = 23;
+ /// \endcode
+ ACA_AcrossComments
+ };
+
+ /// Style of aligning assignments on consecutive lines.
+ AlignConsecutiveAssignmentsStyle AlignConsecutiveAssignments;
/// If ``true``, aligns consecutive bitfield members.
///
Index: clang/docs/ClangFormatStyleOptions.rst
===================================================================
--- clang/docs/ClangFormatStyleOptions.rst
+++ clang/docs/ClangFormatStyleOptions.rst
@@ -195,7 +195,7 @@
-**AlignConsecutiveAssignments** (``bool``)
+**AlignConsecutiveAssignments** (``AlignConsecutiveAssignmentsStyle``)
If ``true``, aligns consecutive assignments.
This will align the assignment operators of consecutive lines. This
@@ -207,6 +207,54 @@
int b = 23;
int ccc = 23;
+ Possible values:
+
+ * ``ACA_None`` (in configuration: ``None``)
+ Do not align assignments on consecutive lines.
+
+ .. code-block:: c++
+
+ int aaaa = 12;
+ int b = 23;
+ int ccc = 23;
+
+ * ``ACA_Consecutive`` (in configuration: ``Consecutive``)
+ Align assignments on consecutive lines.
+
+ .. code-block:: c++
+
+ int aaaa = 12;
+ int b = 23;
+ int ccc = 23;
+
+ /* Empty lines and comments break alignment */
+ int c = 42;
+
+ * ``ACA_AcrossEmptyLines`` (in configuration: ``AcrossEmptyLines``)
+ Align assignments on consecutive lines, ignoring empty lines in between.
+
+ .. code-block:: c++
+
+ int aaaa = 12;
+ int b = 23;
+
+ int ccc = 23;
+ /* Comments still break alignment */
+ int c = 42;
+
+ * ``ACA_AcrossComments`` (in configuration: ``AcrossComments``)
+ Align assignments on consecutive lines, ignoring empty lines and lines
+ only containing comments in between.
+
+ .. code-block:: c++
+
+ int aaaa = 12;
+ int b = 23;
+
+ int ccc = 23;
+ /* Comments do not break alignment */
+ int c = 42;
+
**AlignConsecutiveBitFields** (``bool``)
If ``true``, aligns consecutive bitfield members.
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
