maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

[clang-format] Option for empty lines after an access modifier. 

The current logic for access modifiers in classes ignores the option 'MaxEmptyLinesToKeep=1'. It is therefore impossible to have a coding style that requests one empty line after an access modifier. The patch allows the user to configure how many empty lines clang-format should add after an access modifier. This will remove lines if there are to many and will add them if there are missing.

Reviewed By: MyDeveloperDay, curdeius

Differential Revision: https://reviews.llvm.org/D98237
This commit is contained in:
Max Sagebaum 2021-04-15 17:27:20 +02:00 committed by Marek Kurdej
parent 915a778098
commit dda978eef8
6 changed files with 686 additions and 5 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

52
clang/docs/ClangFormatStyleOptions.rst
View File

@ -2128,6 +2128,56 @@ the configuration (without a prefix: ``Auto``).
**DisableFormat** (``bool``)
Disables formatting completely.
**EmptyLineAfterAccessModifier** (``EmptyLineAfterAccessModifierStyle``)
Defines when to put an empty line after access modifiers.
``EmptyLineBeforeAccessModifier`` configuration handles the number of
empty lines between two access modifiers.
Possible values:
* ``ELAAMS_Never`` (in configuration: ``Never``)
Remove all empty lines after access modifiers.
.. code-block:: c++
struct foo {
private:
int i;
protected:
int j;
/* comment */
public:
foo() {}
private:
protected:
};
* ``ELAAMS_Leave`` (in configuration: ``Leave``)
Keep existing empty lines after access modifiers.
MaxEmptyLinesToKeep is applied instead.
* ``ELAAMS_Always`` (in configuration: ``Always``)
Always add empty line after access modifiers if there are none.
MaxEmptyLinesToKeep is applied also.
.. code-block:: c++
struct foo {
private:
int i;
protected:
int j;
/* comment */
public:
foo() {}
private:
protected:
};
**EmptyLineBeforeAccessModifier** (``EmptyLineBeforeAccessModifierStyle``)
Defines in which cases to put empty line before access modifiers.
@ -2195,8 +2245,6 @@ the configuration (without a prefix: ``Auto``).
protected:
};
**ExperimentalAutoDetectBinPacking** (``bool``)
If ``true``, clang-format detects whether function calls and
definitions are formatted with one parameter per line.

3
clang/docs/ReleaseNotes.rst
View File

@ -216,6 +216,9 @@ clang-format
- Support for Whitesmiths has been improved, with fixes for ``namespace`` blocks
and ``case`` blocks and labels.
- Option ``EmptyLineAfterAccessModifier`` has been added to remove, force or keep
new lines after access modifiers.
libclang
--------

49
clang/include/clang/Format/Format.h
View File

@ -1891,6 +1891,54 @@ struct FormatStyle {
/// Disables formatting completely.
bool DisableFormat;
/// Different styles for empty line after access modifiers.
/// ``EmptyLineBeforeAccessModifier`` configuration handles the number of
/// empty lines between two access modifiers.
enum EmptyLineAfterAccessModifierStyle : unsigned char {
/// Remove all empty lines after access modifiers.
/// \code
/// struct foo {
/// private:
/// int i;
/// protected:
/// int j;
/// /* comment */
/// public:
/// foo() {}
/// private:
/// protected:
/// };
/// \endcode
ELAAMS_Never,
/// Keep existing empty lines after access modifiers.
/// MaxEmptyLinesToKeep is applied instead.
ELAAMS_Leave,
/// Always add empty line after access modifiers if there are none.
/// MaxEmptyLinesToKeep is applied also.
/// \code
/// struct foo {
/// private:
//
/// int i;
/// protected:
//
/// int j;
/// /* comment */
/// public:
//
/// foo() {}
/// private:
///
/// protected:
//
/// };
/// \endcode
ELAAMS_Always,
};
/// Defines in which cases to put empty line after access modifiers.
EmptyLineAfterAccessModifierStyle EmptyLineAfterAccessModifier;
/// Different styles for empty line before access modifiers.
enum EmptyLineBeforeAccessModifierStyle : unsigned char {
/// Remove all empty lines before access modifiers.
@ -3200,6 +3248,7 @@ struct FormatStyle {
DeriveLineEnding == R.DeriveLineEnding &&
DerivePointerAlignment == R.DerivePointerAlignment &&
DisableFormat == R.DisableFormat &&
EmptyLineAfterAccessModifier == R.EmptyLineAfterAccessModifier &&
EmptyLineBeforeAccessModifier == R.EmptyLineBeforeAccessModifier &&
ExperimentalAutoDetectBinPacking ==
R.ExperimentalAutoDetectBinPacking &&

13
clang/lib/Format/Format.cpp
View File

@ -241,6 +241,16 @@ struct ScalarEnumerationTraits<FormatStyle::BreakInheritanceListStyle> {
}
};
template <>
struct ScalarEnumerationTraits<FormatStyle::EmptyLineAfterAccessModifierStyle> {
static void
enumeration(IO &IO, FormatStyle::EmptyLineAfterAccessModifierStyle &Value) {
IO.enumCase(Value, "Never", FormatStyle::ELAAMS_Never);
IO.enumCase(Value, "Leave", FormatStyle::ELAAMS_Leave);
IO.enumCase(Value, "Always", FormatStyle::ELAAMS_Always);
}
};
template <>
struct ScalarEnumerationTraits<
FormatStyle::EmptyLineBeforeAccessModifierStyle> {
@ -584,6 +594,8 @@ template <> struct MappingTraits<FormatStyle> {
IO.mapOptional("DeriveLineEnding", Style.DeriveLineEnding);
IO.mapOptional("DerivePointerAlignment", Style.DerivePointerAlignment);
IO.mapOptional("DisableFormat", Style.DisableFormat);
IO.mapOptional("EmptyLineAfterAccessModifier",
Style.EmptyLineAfterAccessModifier);
IO.mapOptional("EmptyLineBeforeAccessModifier",
Style.EmptyLineBeforeAccessModifier);
IO.mapOptional("ExperimentalAutoDetectBinPacking",
@ -974,6 +986,7 @@ FormatStyle getLLVMStyle(FormatStyle::LanguageKind Language) {
LLVMStyle.Cpp11BracedListStyle = true;
LLVMStyle.DeriveLineEnding = true;
LLVMStyle.DerivePointerAlignment = false;
LLVMStyle.EmptyLineAfterAccessModifier = FormatStyle::ELAAMS_Never;
LLVMStyle.EmptyLineBeforeAccessModifier = FormatStyle::ELBAMS_LogicalBlock;
LLVMStyle.ExperimentalAutoDetectBinPacking = false;
LLVMStyle.FixNamespaceComments = true;

26
clang/lib/Format/UnwrappedLineFormatter.cpp
View File

@ -1264,6 +1264,8 @@ void UnwrappedLineFormatter::formatFirstToken(
if (PreviousLine->Last->isOneOf(tok::semi, tok::r_brace) &&
RootToken.NewlinesBefore <= 1)
Newlines = 2;
if (PreviousLine->First->isAccessSpecifier())
Newlines = 1; // Previous is an access modifier remove all new lines.
break;
case FormatStyle::ELBAMS_Always: {
const FormatToken *previousToken;
@ -1278,10 +1280,28 @@ void UnwrappedLineFormatter::formatFirstToken(
}
}
// Remove empty lines after access specifiers.
// Insert or remove empty line after access specifiers.
if (PreviousLine && PreviousLine->First->isAccessSpecifier() &&
(!PreviousLine->InPPDirective || !RootToken.HasUnescapedNewline))
Newlines = std::min(1u, Newlines);
(!PreviousLine->InPPDirective || !RootToken.HasUnescapedNewline)) {
// EmptyLineBeforeAccessModifier is handling the case when two access
// modifiers follow each other.
if (!RootToken.isAccessSpecifier()) {
switch (Style.EmptyLineAfterAccessModifier) {
case FormatStyle::ELAAMS_Never:
Newlines = 1;
break;
case FormatStyle::ELAAMS_Leave:
Newlines = std::max(Newlines, 1u);
break;
case FormatStyle::ELAAMS_Always:
if (RootToken.is(tok::r_brace)) // Do not add at end of class.
Newlines = 1u;
else
Newlines = std::max(Newlines, 2u);
break;
}
}
}
if (Newlines)
Indent = NewlineIndent;

548
clang/unittests/Format/FormatTest.cpp
View File

@ -9179,6 +9179,554 @@ TEST_F(FormatTest, FormatsAccessModifiers) {
Style);
}
TEST_F(FormatTest, FormatsAfterAccessModifiers) {
FormatStyle Style = getLLVMStyle();
EXPECT_EQ(Style.EmptyLineAfterAccessModifier, FormatStyle::ELAAMS_Never);
verifyFormat("struct foo {\n"
"private:\n"
" void f() {}\n"
"\n"
"private:\n"
" int i;\n"
"\n"
"protected:\n"
" int j;\n"
"};\n",
Style);
// Check if lines are removed.
verifyFormat("struct foo {\n"
"private:\n"
" void f() {}\n"
"\n"
"private:\n"
" int i;\n"
"\n"
"protected:\n"
" int j;\n"
"};\n",
"struct foo {\n"
"private:\n"
"\n"
" void f() {}\n"
"\n"
"private:\n"
"\n"
" int i;\n"
"\n"
"protected:\n"
"\n"
" int j;\n"
"};\n",
Style);
Style.EmptyLineAfterAccessModifier = FormatStyle::ELAAMS_Always;
verifyFormat("struct foo {\n"
"private:\n"
"\n"
" void f() {}\n"
"\n"
"private:\n"
"\n"
" int i;\n"
"\n"
"protected:\n"
"\n"
" int j;\n"
"};\n",
Style);
// Check if lines are added.
verifyFormat("struct foo {\n"
"private:\n"
"\n"
" void f() {}\n"
"\n"
"private:\n"
"\n"
" int i;\n"
"\n"
"protected:\n"
"\n"
" int j;\n"
"};\n",
"struct foo {\n"
"private:\n"
" void f() {}\n"
"\n"
"private:\n"
" int i;\n"
"\n"
"protected:\n"
" int j;\n"
"};\n",
Style);
// Leave tests rely on the code layout, test::messUp can not be used.
Style.EmptyLineAfterAccessModifier = FormatStyle::ELAAMS_Leave;
Style.MaxEmptyLinesToKeep = 0u;
EXPECT_EQ("struct foo {\n"
"private:\n"
" void f() {}\n"
"private:\n"
" int i;\n"
"protected:\n"
" int j;\n"
"};\n",
format("struct foo {\n"
"private:\n"
" void f() {}\n"
"\n"
"private:\n"
" int i;\n"
"\n"
"protected:\n"
" int j;\n"
"};\n",
Style));
// Check if MaxEmptyLinesToKeep is respected.
EXPECT_EQ("struct foo {\n"
"private:\n"
" void f() {}\n"
"private:\n"
" int i;\n"
"protected:\n"
" int j;\n"
"};\n",
format("struct foo {\n"
"private:\n"
"\n\n\n"
" void f() {}\n"
"\n"
"private:\n"
"\n\n\n"
" int i;\n"
"\n"
"protected:\n"
"\n\n\n"
" int j;\n"
"};\n",
Style));
Style.MaxEmptyLinesToKeep = 1u;
EXPECT_EQ("struct foo {\n"
"private:\n"
"\n"
" void f() {}\n"
"\n"
"private:\n"
"\n"
" int i;\n"
"\n"
"protected:\n"
"\n"
" int j;\n"
"};\n",
format("struct foo {\n"
"private:\n"
"\n"
" void f() {}\n"
"\n"
"private:\n"
"\n"
" int i;\n"
"\n"
"protected:\n"
"\n"
" int j;\n"
"};\n",
Style));
// Check if no lines are kept.
EXPECT_EQ("struct foo {\n"
"private:\n"
" void f() {}\n"
"\n"
"private:\n"
" int i;\n"
"\n"
"protected:\n"
" int j;\n"
"};\n",
format("struct foo {\n"
"private:\n"
" void f() {}\n"
"\n"
"private:\n"
" int i;\n"
"\n"
"protected:\n"
" int j;\n"
"};\n",
Style));
// Check if MaxEmptyLinesToKeep is respected.
EXPECT_EQ("struct foo {\n"
"private:\n"
"\n"
" void f() {}\n"
"\n"
"private:\n"
"\n"
" int i;\n"
"\n"
"protected:\n"
"\n"
" int j;\n"
"};\n",
format("struct foo {\n"
"private:\n"
"\n\n\n"
" void f() {}\n"
"\n"
"private:\n"
"\n\n\n"
" int i;\n"
"\n"
"protected:\n"
"\n\n\n"
" int j;\n"
"};\n",
Style));
Style.MaxEmptyLinesToKeep = 10u;
EXPECT_EQ("struct foo {\n"
"private:\n"
"\n\n\n"
" void f() {}\n"
"\n"
"private:\n"
"\n\n\n"
" int i;\n"
"\n"
"protected:\n"
"\n\n\n"
" int j;\n"
"};\n",
format("struct foo {\n"
"private:\n"
"\n\n\n"
" void f() {}\n"
"\n"
"private:\n"
"\n\n\n"
" int i;\n"
"\n"
"protected:\n"
"\n\n\n"
" int j;\n"
"};\n",
Style));
// Test with comments.
Style = getLLVMStyle();
verifyFormat("struct foo {\n"
"private:\n"
" // comment\n"
" void f() {}\n"
"\n"
"private: /* comment */\n"
" int i;\n"
"};\n",
Style);
verifyFormat("struct foo {\n"
"private:\n"
" // comment\n"
" void f() {}\n"
"\n"
"private: /* comment */\n"
" int i;\n"
"};\n",
"struct foo {\n"
"private:\n"
"\n"
" // comment\n"
" void f() {}\n"
"\n"
"private: /* comment */\n"
"\n"
" int i;\n"
"};\n",
Style);
Style.EmptyLineAfterAccessModifier = FormatStyle::ELAAMS_Always;
verifyFormat("struct foo {\n"
"private:\n"
"\n"
" // comment\n"
" void f() {}\n"
"\n"
"private: /* comment */\n"
"\n"
" int i;\n"
"};\n",
"struct foo {\n"
"private:\n"
" // comment\n"
" void f() {}\n"
"\n"
"private: /* comment */\n"
" int i;\n"
"};\n",
Style);
verifyFormat("struct foo {\n"
"private:\n"
"\n"
" // comment\n"
" void f() {}\n"
"\n"
"private: /* comment */\n"
"\n"
" int i;\n"
"};\n",
Style);
// Test with preprocessor defines.
Style = getLLVMStyle();
verifyFormat("struct foo {\n"
"private:\n"
"#ifdef FOO\n"
"#endif\n"
" void f() {}\n"
"};\n",
Style);
verifyFormat("struct foo {\n"
"private:\n"
"#ifdef FOO\n"
"#endif\n"
" void f() {}\n"
"};\n",
"struct foo {\n"
"private:\n"
"\n"
"#ifdef FOO\n"
"#endif\n"
" void f() {}\n"
"};\n",
Style);
Style.EmptyLineAfterAccessModifier = FormatStyle::ELAAMS_Always;
verifyFormat("struct foo {\n"
"private:\n"
"\n"
"#ifdef FOO\n"
"#endif\n"
" void f() {}\n"
"};\n",
"struct foo {\n"
"private:\n"
"#ifdef FOO\n"
"#endif\n"
" void f() {}\n"
"};\n",
Style);
verifyFormat("struct foo {\n"
"private:\n"
"\n"
"#ifdef FOO\n"
"#endif\n"
" void f() {}\n"
"};\n",
Style);
}
TEST_F(FormatTest, FormatsAfterAndBeforeAccessModifiersInteraction) {
// Combined tests of EmptyLineAfterAccessModifier and
// EmptyLineBeforeAccessModifier.
FormatStyle Style = getLLVMStyle();
Style.EmptyLineBeforeAccessModifier = FormatStyle::ELBAMS_Always;
Style.EmptyLineAfterAccessModifier = FormatStyle::ELAAMS_Always;
verifyFormat("struct foo {\n"
"private:\n"
"\n"
"protected:\n"
"};\n",
Style);
Style.MaxEmptyLinesToKeep = 10u;
// Both remove all new lines.
Style.EmptyLineBeforeAccessModifier = FormatStyle::ELBAMS_Never;
Style.EmptyLineAfterAccessModifier = FormatStyle::ELAAMS_Never;
verifyFormat("struct foo {\n"
"private:\n"
"protected:\n"
"};\n",
"struct foo {\n"
"private:\n"
"\n\n\n"
"protected:\n"
"};\n",
Style);
// Leave tests rely on the code layout, test::messUp can not be used.
Style.EmptyLineBeforeAccessModifier = FormatStyle::ELBAMS_Leave;
Style.EmptyLineAfterAccessModifier = FormatStyle::ELAAMS_Leave;
Style.MaxEmptyLinesToKeep = 10u;
EXPECT_EQ("struct foo {\n"
"private:\n"
"\n\n\n"
"protected:\n"
"};\n",
format("struct foo {\n"
"private:\n"
"\n\n\n"
"protected:\n"
"};\n",
Style));
Style.MaxEmptyLinesToKeep = 3u;
EXPECT_EQ("struct foo {\n"
"private:\n"
"\n\n\n"
"protected:\n"
"};\n",
format("struct foo {\n"
"private:\n"
"\n\n\n"
"protected:\n"
"};\n",
Style));
Style.MaxEmptyLinesToKeep = 1u;
EXPECT_EQ("struct foo {\n"
"private:\n"
"\n\n\n"
"protected:\n"
"};\n",
format("struct foo {\n"
"private:\n"
"\n\n\n"
"protected:\n"
"};\n",
Style)); // Based on new lines in original document and not
// on the setting.
Style.MaxEmptyLinesToKeep = 10u;
Style.EmptyLineBeforeAccessModifier = FormatStyle::ELBAMS_Always;
Style.EmptyLineAfterAccessModifier = FormatStyle::ELAAMS_Leave;
// Newlines are kept if they are greater than zero,
// test::messUp removes all new lines which changes the logic
EXPECT_EQ("struct foo {\n"
"private:\n"
"\n\n\n"
"protected:\n"
"};\n",
format("struct foo {\n"
"private:\n"
"\n\n\n"
"protected:\n"
"};\n",
Style));
Style.EmptyLineBeforeAccessModifier = FormatStyle::ELBAMS_Leave;
Style.EmptyLineAfterAccessModifier = FormatStyle::ELAAMS_Always;
// test::messUp removes all new lines which changes the logic
EXPECT_EQ("struct foo {\n"
"private:\n"
"\n\n\n"
"protected:\n"
"};\n",
format("struct foo {\n"
"private:\n"
"\n\n\n"
"protected:\n"
"};\n",
Style));
Style.EmptyLineBeforeAccessModifier = FormatStyle::ELBAMS_Leave;
Style.EmptyLineAfterAccessModifier = FormatStyle::ELAAMS_Never;
EXPECT_EQ("struct foo {\n"
"private:\n"
"\n\n\n"
"protected:\n"
"};\n",
format("struct foo {\n"
"private:\n"
"\n\n\n"
"protected:\n"
"};\n",
Style)); // test::messUp removes all new lines which changes
// the logic.
Style.EmptyLineBeforeAccessModifier = FormatStyle::ELBAMS_Never;
Style.EmptyLineAfterAccessModifier = FormatStyle::ELAAMS_Leave;
verifyFormat("struct foo {\n"
"private:\n"
"protected:\n"
"};\n",
"struct foo {\n"
"private:\n"
"\n\n\n"
"protected:\n"
"};\n",
Style);
Style.EmptyLineBeforeAccessModifier = FormatStyle::ELBAMS_Always;
Style.EmptyLineAfterAccessModifier = FormatStyle::ELAAMS_Never;
EXPECT_EQ("struct foo {\n"
"private:\n"
"\n\n\n"
"protected:\n"
"};\n",
format("struct foo {\n"
"private:\n"
"\n\n\n"
"protected:\n"
"};\n",
Style)); // test::messUp removes all new lines which changes
// the logic.
Style.EmptyLineBeforeAccessModifier = FormatStyle::ELBAMS_Never;
Style.EmptyLineAfterAccessModifier = FormatStyle::ELAAMS_Always;
verifyFormat("struct foo {\n"
"private:\n"
"protected:\n"
"};\n",
"struct foo {\n"
"private:\n"
"\n\n\n"
"protected:\n"
"};\n",
Style);
Style.EmptyLineBeforeAccessModifier = FormatStyle::ELBAMS_LogicalBlock;
Style.EmptyLineAfterAccessModifier = FormatStyle::ELAAMS_Always;
verifyFormat("struct foo {\n"
"private:\n"
"protected:\n"
"};\n",
"struct foo {\n"
"private:\n"
"\n\n\n"
"protected:\n"
"};\n",
Style);
Style.EmptyLineBeforeAccessModifier = FormatStyle::ELBAMS_LogicalBlock;
Style.EmptyLineAfterAccessModifier = FormatStyle::ELAAMS_Leave;
verifyFormat("struct foo {\n"
"private:\n"
"protected:\n"
"};\n",
"struct foo {\n"
"private:\n"
"\n\n\n"
"protected:\n"
"};\n",
Style);
Style.EmptyLineBeforeAccessModifier = FormatStyle::ELBAMS_LogicalBlock;
Style.EmptyLineAfterAccessModifier = FormatStyle::ELAAMS_Never;
verifyFormat("struct foo {\n"
"private:\n"
"protected:\n"
"};\n",
"struct foo {\n"
"private:\n"
"\n\n\n"
"protected:\n"
"};\n",
Style);
}
TEST_F(FormatTest, FormatsArrays) {
verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaaaaaaaaaa]\n"
" [bbbbbbbbbbbbbbbbbbbbbbbbb] = c;");