MyDeveloperDay created this revision.
MyDeveloperDay added reviewers: klimek, owenpan.
MyDeveloperDay added a project: clang-tools-extra.
Herald added a project: clang.
This is to address a request made in https://bugs.llvm.org/show_bug.cgi?id=43144
Add the ability to not have a space before and after brace (limited to
if,else,for,while,do keyword (for now))
if (x){
}else if{
}else{
}
do{
}while(x)
while(x){
}
for(int i=0;i<size();i++){
}
nb. I have not affiliation with the 3sfs project
(https://github.com/s3fs-fuse/s3fs-fuse) but noticed on reading this request
they don't have a .clang-format file in their Github repo. Perhaps this is
because without this feature we can't support their style at all. My aim here
is to further the reach of clang-format whilst increasing my knowledge of the
workings for clang-format.
Repository:
rC Clang
https://reviews.llvm.org/D67773
Files:
clang/docs/ClangFormatStyleOptions.rst
clang/include/clang/Format/Format.h
clang/lib/Format/Format.cpp
clang/lib/Format/TokenAnnotator.cpp
clang/unittests/Format/FormatTest.cpp
Index: clang/unittests/Format/FormatTest.cpp
===================================================================
--- clang/unittests/Format/FormatTest.cpp
+++ clang/unittests/Format/FormatTest.cpp
@@ -1596,7 +1596,7 @@
TEST_F(FormatTest, BreakInheritanceStyle) {
FormatStyle StyleWithInheritanceBreakBeforeComma = getLLVMStyle();
StyleWithInheritanceBreakBeforeComma.BreakInheritanceList =
- FormatStyle::BILS_BeforeComma;
+ FormatStyle::BILS_BeforeComma;
verifyFormat("class MyClass : public X {};",
StyleWithInheritanceBreakBeforeComma);
verifyFormat("class MyClass\n"
@@ -1614,7 +1614,7 @@
FormatStyle StyleWithInheritanceBreakAfterColon = getLLVMStyle();
StyleWithInheritanceBreakAfterColon.BreakInheritanceList =
- FormatStyle::BILS_AfterColon;
+ FormatStyle::BILS_AfterColon;
verifyFormat("class MyClass : public X {};",
StyleWithInheritanceBreakAfterColon);
verifyFormat("class MyClass : public X, public Y {};",
@@ -2086,8 +2086,8 @@
Style.NamespaceMacros.push_back("TESTSUITE");
verifyFormat("namespace A { namespace B {\n"
- "}} // namespace A::B",
- Style);
+ "}} // namespace A::B",
+ Style);
EXPECT_EQ("namespace out { namespace in {\n"
"}} // namespace out::in",
@@ -4450,28 +4450,28 @@
"SomeClass::Constructor() :\n"
" aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
" aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}",
- Style);
+ Style);
verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
" aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n"
" aaaaaaaaaa(aaaaaa) {}",
- Style);
+ Style);
verifyFormat("Constructor() :\n"
" aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
" aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
" aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
" aaaaaaaaaaaaaaaaaaaaaaa() {}",
- Style);
+ Style);
verifyFormat("Constructor() :\n"
" aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
" aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
- Style);
+ Style);
verifyFormat("Constructor(int Parameter = 0) :\n"
" aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n"
" aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}",
- Style);
+ Style);
verifyFormat("Constructor() :\n"
" aaaaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n"
"}",
@@ -4479,7 +4479,7 @@
verifyFormat("Constructor() :\n"
" aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
" aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}",
- Style);
+ Style);
// Here a line could be saved by splitting the second initializer onto two
// lines, but that is not desirable.
@@ -4487,7 +4487,7 @@
" aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n"
" aaaaaaaaaaa(aaaaaaaaaaa),\n"
" aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
- Style);
+ Style);
FormatStyle OnePerLine = Style;
OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
@@ -4521,10 +4521,10 @@
OnePerLine.BinPackParameters = false;
verifyFormat(
"Constructor() :\n"
- " aaaaaaaaaaaaaaaaaaaaaaaa(\n"
- " aaaaaaaaaaa().aaa(),\n"
- " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
- OnePerLine);
+ " aaaaaaaaaaaaaaaaaaaaaaaa(\n"
+ " aaaaaaaaaaa().aaa(),\n"
+ " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
+ OnePerLine);
OnePerLine.ColumnLimit = 60;
verifyFormat("Constructor() :\n"
" aaaaaaaaaaaaaaaaaaaa(a),\n"
@@ -4537,7 +4537,7 @@
format("Constructor() :\n"
" // Comment forcing unwanted break.\n"
" aaaa(aaaa) {}",
- Style));
+ Style));
Style.ColumnLimit = 0;
verifyFormat("SomeClass::Constructor() :\n"
@@ -4547,7 +4547,7 @@
" a(a) {}",
Style);
verifyFormat("SomeClass::Constructor() :\n"
- " a(a), b(b), c(c) {}",
+ " a(a), b(b), c(c) {}",
Style);
verifyFormat("SomeClass::Constructor() :\n"
" a(a) {\n"
@@ -4558,12 +4558,12 @@
Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
verifyFormat("SomeClass::Constructor() :\n"
- " a(a), b(b), c(c) {\n"
- "}",
+ " a(a), b(b), c(c) {\n"
+ "}",
Style);
verifyFormat("SomeClass::Constructor() :\n"
" a(a) {\n"
- "}",
+ "}",
Style);
Style.ColumnLimit = 80;
@@ -4579,19 +4579,19 @@
// `ConstructorInitializerIndentWidth` actually applies to InheritanceList as well
Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon;
verifyFormat("class SomeClass\n"
- " : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
- " public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};",
- Style);
+ " : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
+ " public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};",
+ Style);
Style.BreakInheritanceList = FormatStyle::BILS_BeforeComma;
verifyFormat("class SomeClass\n"
- " : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
- " , public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};",
- Style);
+ " : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+ " , public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};",
+ Style);
Style.BreakInheritanceList = FormatStyle::BILS_AfterColon;
verifyFormat("class SomeClass :\n"
- " public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
- " public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};",
- Style);
+ " public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
+ " public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};",
+ Style);
}
#ifndef EXPENSIVE_CHECKS
@@ -4779,9 +4779,9 @@
" bool *aaaaaaaaaaaaaaaaaa, bool *aa) {}");
verifyGoogleFormat(
"template <typename T>\n"
- "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
- "aaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaaaaa(\n"
- " aaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaa);");
+ "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+ "aaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaaaaa(\n"
+ " aaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaa);");
FormatStyle Style = getLLVMStyle();
Style.PointerAlignment = FormatStyle::PAS_Left;
@@ -5156,9 +5156,9 @@
" aaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa();");
verifyFormat(
"aaaaaaa->aaaaaaa\n"
- " ->aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
- " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
- " ->aaaaaaaa(aaaaaaaaaaaaaaa);");
+ " ->aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
+ " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
+ " ->aaaaaaaa(aaaaaaaaaaaaaaa);");
verifyFormat(
"aaaaaaa->aaaaaaa\n"
" ->aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
@@ -5517,8 +5517,8 @@
" : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
verifyFormat(
"aaaa(aaaaaaaaa, aaaaaaaaa,\n"
- " aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
- " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
+ " aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
+ " : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
verifyFormat(
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa)\n"
" : aaaaaaaaaaaaa);");
@@ -5662,9 +5662,9 @@
Style);
verifyFormat(
"aaaa(aaaaaaaa, aaaaaaaaaa,\n"
- " aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
- " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
- Style);
+ " aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
+ " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
+ Style);
verifyFormat(
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa) :\n"
" aaaaaaaaaaaaa);",
@@ -6562,20 +6562,20 @@
Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
verifyFormat(
"template <typename... a> struct s {};\n"
- "extern s<\n"
+ "extern s<\n"
" aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n"
" aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa>\n"
- " y;",
- Style);
+ " y;",
+ Style);
Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
verifyFormat(
"template <typename... a> struct t {};\n"
- "extern t<\n"
+ "extern t<\n"
" aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n"
" aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa>\n"
- " y;",
- Style);
+ " y;",
+ Style);
}
TEST_F(FormatTest, WrapsAtNestedNameSpecifiers) {
@@ -6604,10 +6604,10 @@
verifyFormat(
"aaaaaaaaaaaaaaaaaa(aaaaaaaa,\n"
- " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
- " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
- " aaaaaaaaaaaaaaaaaaaaa);",
- getLLVMStyleWithColumns(74));
+ " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
+ " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
+ " aaaaaaaaaaaaaaaaaaaaa);",
+ getLLVMStyleWithColumns(74));
verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
" aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
@@ -7077,12 +7077,12 @@
getLLVMStyleWithColumns(70));
verifyFormat(
"template <class T,\n"
- " class = typename std::enable_if<\n"
- " std::is_integral<T>::value &&\n"
- " (sizeof(T) > 1 || sizeof(T) < 8)>::type,\n"
- " class U>\n"
- "void F();",
- getLLVMStyleWithColumns(70));
+ " class = typename std::enable_if<\n"
+ " std::is_integral<T>::value &&\n"
+ " (sizeof(T) > 1 || sizeof(T) < 8)>::type,\n"
+ " class U>\n"
+ "void F();",
+ getLLVMStyleWithColumns(70));
verifyFormat(
"template <class T,\n"
" class = typename ::std::enable_if<\n"
@@ -7801,7 +7801,7 @@
// Binpacking only if there is no trailing comma
verifyFormat("const Aaaaaa aaaaa = {aaaaaaaaaa, bbbbbbbbbb,\n"
" cccccccccc, dddddddddd};",
- getLLVMStyleWithColumns(50));
+ getLLVMStyleWithColumns(50));
verifyFormat("const Aaaaaa aaaaa = {\n"
" aaaaaaaaaaa,\n"
" bbbbbbbbbbb,\n"
@@ -8991,12 +8991,12 @@
// Style::AlwaysBreakBeforeMultilineStrings.
EXPECT_EQ(
"aaaaaaaaaaaa(\n"
- " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa \"\n"
- " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\");",
- format("aaaaaaaaaaaa(\"aaaaaaaaaaaaaaaaaaaaaaaaaa "
- "aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa "
- "aaaaaaaaaaaaaaaaaaaaaa\");",
- getGoogleStyle()));
+ " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa \"\n"
+ " \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\");",
+ format("aaaaaaaaaaaa(\"aaaaaaaaaaaaaaaaaaaaaaaaaa "
+ "aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa "
+ "aaaaaaaaaaaaaaaaaaaaaa\");",
+ getGoogleStyle()));
EXPECT_EQ("return \"aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
" \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\";",
format("return \"aaaaaaaaaaaaaaaaaaaaaa "
@@ -9134,7 +9134,7 @@
// In a function call with two operands, the second can be broken with no line
// break before it.
EXPECT_EQ("func(a, \"long long \"\n"
- " \"long long\");",
+ " \"long long\");",
format("func(a, \"long long long long\");",
getLLVMStyleWithColumns(24)));
// In a function call with three operands, the second must be broken with a
@@ -9170,15 +9170,15 @@
// In a chain of << with three operands, the second can be broken with no line
// break before it.
EXPECT_EQ("abcde << \"line \"\n"
- " \"line line\"\n"
- " << c;",
+ " \"line line\"\n"
+ " << c;",
format("abcde << \"line line line\" << c;",
getLLVMStyleWithColumns(20)));
// In a chain of << with three operands, the third must be broken with a line
// break before it.
EXPECT_EQ("a << b\n"
- " << \"line line \"\n"
- " \"line\";",
+ " << \"line line \"\n"
+ " \"line\";",
format("a << b << \"line line line\";",
getLLVMStyleWithColumns(20)));
// In a chain of << with three operands, the second can be broken with no line
@@ -9192,7 +9192,7 @@
// In a chain of binary operators with two operands, the second can be broken
// with no line break before it.
EXPECT_EQ("abcd + \"line line \"\n"
- " \"line line\";",
+ " \"line line\";",
format("abcd + \"line line line line\";",
getLLVMStyleWithColumns(20)));
// In a chain of binary operators with three operands, the second must be
@@ -11649,8 +11649,8 @@
// cheaper than keeping protruding characters.
Style.ColumnLimit = 21;
EXPECT_EQ("// foo foo foo foo\n"
- "// foo foo foo foo\n"
- "// foo foo foo foo\n",
+ "// foo foo foo foo\n"
+ "// foo foo foo foo\n",
format("// foo foo foo foo foo foo foo foo foo foo foo foo\n",
Style));
@@ -11822,6 +11822,7 @@
CHECK_PARSE_BOOL(SpaceAfterCStyleCast);
CHECK_PARSE_BOOL(SpaceAfterTemplateKeyword);
CHECK_PARSE_BOOL(SpaceAfterLogicalNot);
+ CHECK_PARSE_BOOL(SpaceAroundBraces);
CHECK_PARSE_BOOL(SpaceBeforeAssignmentOperators);
CHECK_PARSE_BOOL(SpaceBeforeCpp11BracedList);
CHECK_PARSE_BOOL(SpaceBeforeCtorInitializerColon);
@@ -12346,17 +12347,17 @@
getLLVMStyleWithColumns(13)));
EXPECT_EQ(
"\"一 二 三 \"\n"
- "\"四 五六 \"\n"
- "\"七 八 九 \"\n"
- "\"十\"",
- format("\"一 二 三 四 五六 七 八 九 十\"", getLLVMStyleWithColumns(11)));
+ "\"四 五六 \"\n"
+ "\"七 八 九 \"\n"
+ "\"十\"",
+ format("\"一 二 三 四 五六 七 八 九 十\"", getLLVMStyleWithColumns(11)));
EXPECT_EQ("\"一\t\"\n"
- "\"二 \t\"\n"
- "\"三 四 \"\n"
- "\"五\t\"\n"
- "\"六 \t\"\n"
- "\"七 \"\n"
- "\"八九十\tqq\"",
+ "\"二 \t\"\n"
+ "\"三 四 \"\n"
+ "\"五\t\"\n"
+ "\"六 \t\"\n"
+ "\"七 \"\n"
+ "\"八九十\tqq\"",
format("\"一\t二 \t三 四 五\t六 \t七 八九十\tqq\"",
getLLVMStyleWithColumns(11)));
@@ -12405,10 +12406,10 @@
getLLVMStyleWithColumns(13)));
EXPECT_EQ(
"/* 一二三\n"
- " * 四五六七\n"
- " * 八 九\n"
- " * 十 */",
- format("/* 一二三 四五六七 八 九 十 */", getLLVMStyleWithColumns(9)));
+ " * 四五六七\n"
+ " * 八 九\n"
+ " * 十 */",
+ format("/* 一二三 四五六七 八 九 十 */", getLLVMStyleWithColumns(9)));
EXPECT_EQ("/* 𝓣𝓮𝓼𝓽 𝔣𝔬𝔲𝔯\n"
" * 𝕓𝕪𝕥𝕖\n"
" * 𝖀𝕿𝕱-𝟠 */",
@@ -12448,14 +12449,14 @@
verifyFormat(
"bool smaller = 1 < bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
" aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
- Style);
+ Style);
Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon;
verifyFormat(
"SomeClass::Constructor() :\n"
- "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa),\n"
- "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa) {}",
- Style);
+ "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa),\n"
+ "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa) {}",
+ Style);
}
TEST_F(FormatTest, BreakConstructorInitializersBeforeComma) {
@@ -12732,12 +12733,12 @@
" [something, rather](int, int, int, int, int, int, int) { return 1; });\n"
"}\n");
verifyFormat("void f() {\n"
- " other.other.other.other.other(\n"
- " x.begin(), x.end(),\n"
- " [something, rather](int, int, int, int, int, int, int) {\n"
- " //\n"
- " });\n"
- "}\n");
+ " other.other.other.other.other(\n"
+ " x.begin(), x.end(),\n"
+ " [something, rather](int, int, int, int, int, int, int) {\n"
+ " //\n"
+ " });\n"
+ "}\n");
verifyFormat("SomeFunction([]() { // A cool function...\n"
" return 43;\n"
"});");
@@ -12790,8 +12791,8 @@
" // comment\n"
"}});");
verifyFormat("virtual aaaaaaaaaaaaaaaa(\n"
- " std::function<bool()> bbbbbbbbbbbb = [&]() { return true; },\n"
- " aaaaa aaaaaaaaa);");
+ " std::function<bool()> bbbbbbbbbbbb = [&]() { return true; },\n"
+ " aaaaa aaaaaaaaa);");
// Lambdas with return types.
verifyFormat("int c = []() -> int { return 2; }();\n");
@@ -12822,77 +12823,77 @@
verifyFormat("[]() -> foo<5 < 2> { return {}; };");
verifyFormat("[]() -> foo<2 ? 1 : 0> { return {}; };");
verifyFormat("namespace bar {\n"
- "// broken:\n"
- "auto foo{[]() -> foo<5 + 2> { return {}; }};\n"
- "} // namespace bar");
+ "// broken:\n"
+ "auto foo{[]() -> foo<5 + 2> { return {}; }};\n"
+ "} // namespace bar");
verifyFormat("namespace bar {\n"
- "// broken:\n"
- "auto foo{[]() -> foo<5 - 2> { return {}; }};\n"
- "} // namespace bar");
+ "// broken:\n"
+ "auto foo{[]() -> foo<5 - 2> { return {}; }};\n"
+ "} // namespace bar");
verifyFormat("namespace bar {\n"
- "// broken:\n"
- "auto foo{[]() -> foo<5 / 2> { return {}; }};\n"
- "} // namespace bar");
+ "// broken:\n"
+ "auto foo{[]() -> foo<5 / 2> { return {}; }};\n"
+ "} // namespace bar");
verifyFormat("namespace bar {\n"
- "// broken:\n"
- "auto foo{[]() -> foo<5 * 2> { return {}; }};\n"
- "} // namespace bar");
+ "// broken:\n"
+ "auto foo{[]() -> foo<5 * 2> { return {}; }};\n"
+ "} // namespace bar");
verifyFormat("namespace bar {\n"
- "// broken:\n"
- "auto foo{[]() -> foo<5 % 2> { return {}; }};\n"
- "} // namespace bar");
+ "// broken:\n"
+ "auto foo{[]() -> foo<5 % 2> { return {}; }};\n"
+ "} // namespace bar");
verifyFormat("namespace bar {\n"
- "// broken:\n"
- "auto foo{[]() -> foo<5 << 2> { return {}; }};\n"
- "} // namespace bar");
+ "// broken:\n"
+ "auto foo{[]() -> foo<5 << 2> { return {}; }};\n"
+ "} // namespace bar");
verifyFormat("namespace bar {\n"
- "// broken:\n"
- "auto foo{[]() -> foo<!5> { return {}; }};\n"
- "} // namespace bar");
+ "// broken:\n"
+ "auto foo{[]() -> foo<!5> { return {}; }};\n"
+ "} // namespace bar");
verifyFormat("namespace bar {\n"
- "// broken:\n"
- "auto foo{[]() -> foo<~5> { return {}; }};\n"
- "} // namespace bar");
+ "// broken:\n"
+ "auto foo{[]() -> foo<~5> { return {}; }};\n"
+ "} // namespace bar");
verifyFormat("namespace bar {\n"
- "// broken:\n"
- "auto foo{[]() -> foo<5 | 2> { return {}; }};\n"
- "} // namespace bar");
+ "// broken:\n"
+ "auto foo{[]() -> foo<5 | 2> { return {}; }};\n"
+ "} // namespace bar");
verifyFormat("namespace bar {\n"
- "// broken:\n"
- "auto foo{[]() -> foo<5 || 2> { return {}; }};\n"
- "} // namespace bar");
+ "// broken:\n"
+ "auto foo{[]() -> foo<5 || 2> { return {}; }};\n"
+ "} // namespace bar");
verifyFormat("namespace bar {\n"
- "// broken:\n"
- "auto foo{[]() -> foo<5 & 2> { return {}; }};\n"
- "} // namespace bar");
+ "// broken:\n"
+ "auto foo{[]() -> foo<5 & 2> { return {}; }};\n"
+ "} // namespace bar");
verifyFormat("namespace bar {\n"
- "// broken:\n"
- "auto foo{[]() -> foo<5 && 2> { return {}; }};\n"
- "} // namespace bar");
+ "// broken:\n"
+ "auto foo{[]() -> foo<5 && 2> { return {}; }};\n"
+ "} // namespace bar");
verifyFormat("namespace bar {\n"
- "// broken:\n"
- "auto foo{[]() -> foo<5 == 2> { return {}; }};\n"
- "} // namespace bar");
+ "// broken:\n"
+ "auto foo{[]() -> foo<5 == 2> { return {}; }};\n"
+ "} // namespace bar");
verifyFormat("namespace bar {\n"
- "// broken:\n"
- "auto foo{[]() -> foo<5 != 2> { return {}; }};\n"
- "} // namespace bar");
+ "// broken:\n"
+ "auto foo{[]() -> foo<5 != 2> { return {}; }};\n"
+ "} // namespace bar");
verifyFormat("namespace bar {\n"
- "// broken:\n"
- "auto foo{[]() -> foo<5 >= 2> { return {}; }};\n"
- "} // namespace bar");
+ "// broken:\n"
+ "auto foo{[]() -> foo<5 >= 2> { return {}; }};\n"
+ "} // namespace bar");
verifyFormat("namespace bar {\n"
- "// broken:\n"
- "auto foo{[]() -> foo<5 <= 2> { return {}; }};\n"
- "} // namespace bar");
+ "// broken:\n"
+ "auto foo{[]() -> foo<5 <= 2> { return {}; }};\n"
+ "} // namespace bar");
verifyFormat("namespace bar {\n"
- "// broken:\n"
- "auto foo{[]() -> foo<5 < 2> { return {}; }};\n"
- "} // namespace bar");
+ "// broken:\n"
+ "auto foo{[]() -> foo<5 < 2> { return {}; }};\n"
+ "} // namespace bar");
verifyFormat("namespace bar {\n"
- "// broken:\n"
- "auto foo{[]() -> foo<2 ? 1 : 0> { return {}; }};\n"
- "} // namespace bar");
+ "// broken:\n"
+ "auto foo{[]() -> foo<2 ? 1 : 0> { return {}; }};\n"
+ "} // namespace bar");
verifyFormat("[]() -> a<1> {};");
verifyFormat("[]() -> a<1> { ; };");
verifyFormat("[]() -> a<1> { ; }();");
@@ -12965,11 +12966,11 @@
// A lambda with a very long line forces arg0 to be pushed out irrespective of
// the BinPackArguments value (as long as the code is wide enough).
verifyFormat("something->SomeFunction(\n"
- " a,\n"
- " [this] {\n"
+ " a,\n"
+ " [this] {\n"
" D0000000000000000000000000000000000000000000000000000000000001();\n"
- " },\n"
- " b);\n");
+ " },\n"
+ " b);\n");
// A multi-line lambda is pulled up as long as the introducer fits on the previous
// line and there are no further args.
@@ -13552,22 +13553,22 @@
// Don't reflow comments within disabled regions.
EXPECT_EQ(
"// clang-format off\n"
- "// long long long long long long line\n"
- "/* clang-format on */\n"
- "/* long long long\n"
- " * long long long\n"
- " * line */\n"
- "int i;\n"
- "/* clang-format off */\n"
- "/* long long long long long long line */\n",
- format("// clang-format off\n"
- "// long long long long long long line\n"
- "/* clang-format on */\n"
- "/* long long long long long long line */\n"
- "int i;\n"
- "/* clang-format off */\n"
- "/* long long long long long long line */\n",
- getLLVMStyleWithColumns(20)));
+ "// long long long long long long line\n"
+ "/* clang-format on */\n"
+ "/* long long long\n"
+ " * long long long\n"
+ " * line */\n"
+ "int i;\n"
+ "/* clang-format off */\n"
+ "/* long long long long long long line */\n",
+ format("// clang-format off\n"
+ "// long long long long long long line\n"
+ "/* clang-format on */\n"
+ "/* long long long long long long line */\n"
+ "int i;\n"
+ "/* clang-format off */\n"
+ "/* long long long long long long line */\n",
+ getLLVMStyleWithColumns(20)));
}
TEST_F(FormatTest, DoNotCrashOnInvalidInput) {
@@ -13923,34 +13924,34 @@
TEST_F(FormatTest, GuessedLanguageWithInlineAsmClobbers) {
EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h",
"void f() {\n"
- " asm (\"mov %[e], %[d]\"\n"
- " : [d] \"=rm\" (d)\n"
- " [e] \"rm\" (*e));\n"
- "}"));
+ " asm (\"mov %[e], %[d]\"\n"
+ " : [d] \"=rm\" (d)\n"
+ " [e] \"rm\" (*e));\n"
+ "}"));
EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h",
"void f() {\n"
- " _asm (\"mov %[e], %[d]\"\n"
- " : [d] \"=rm\" (d)\n"
- " [e] \"rm\" (*e));\n"
- "}"));
+ " _asm (\"mov %[e], %[d]\"\n"
+ " : [d] \"=rm\" (d)\n"
+ " [e] \"rm\" (*e));\n"
+ "}"));
EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h",
"void f() {\n"
- " __asm (\"mov %[e], %[d]\"\n"
- " : [d] \"=rm\" (d)\n"
- " [e] \"rm\" (*e));\n"
- "}"));
+ " __asm (\"mov %[e], %[d]\"\n"
+ " : [d] \"=rm\" (d)\n"
+ " [e] \"rm\" (*e));\n"
+ "}"));
EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h",
"void f() {\n"
- " __asm__ (\"mov %[e], %[d]\"\n"
- " : [d] \"=rm\" (d)\n"
- " [e] \"rm\" (*e));\n"
- "}"));
+ " __asm__ (\"mov %[e], %[d]\"\n"
+ " : [d] \"=rm\" (d)\n"
+ " [e] \"rm\" (*e));\n"
+ "}"));
EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h",
"void f() {\n"
- " asm (\"mov %[e], %[d]\"\n"
- " : [d] \"=rm\" (d),\n"
- " [e] \"rm\" (*e));\n"
- "}"));
+ " asm (\"mov %[e], %[d]\"\n"
+ " : [d] \"=rm\" (d),\n"
+ " [e] \"rm\" (*e));\n"
+ "}"));
EXPECT_EQ(FormatStyle::LK_Cpp,
guessLanguage("foo.h", "void f() {\n"
" asm volatile (\"mov %[e], %[d]\"\n"
@@ -14001,6 +14002,64 @@
verifyFormat("STACK_OF(int*)* a;", Macros);
}
+TEST_F(FormatTest, SpaceAroundBraces) {
+ // supporting a style used by s3fs
+ FormatStyle Style = getLLVMStyle();
+ Style.BreakBeforeBraces = FormatStyle::BS_Attach;
+ Style.SpaceAroundBraces = false;
+ Style.SpaceBeforeParens = FormatStyle::SBPO_Never;
+
+ verifyFormat("if(a){\n"
+ " f();\n"
+ "}else if(b){\n"
+ " h();\n"
+ "}else{\n"
+ " g();\n"
+ "}",
+ Style);
+
+ verifyFormat("while(a){\n"
+ " f();\n"
+ "}",
+ Style);
+
+ verifyFormat("do{\n"
+ " f();\n"
+ "}while(0)",
+ Style);
+
+ verifyFormat("for(int i = 0; i < size(); i++){\n"
+ " f();\n"
+ "}",
+ Style);
+
+ Style.SpaceAroundBraces = true;
+
+ verifyFormat("if(a) {\n"
+ " f();\n"
+ "} else if(b) {\n"
+ " h();\n"
+ "} else {\n"
+ " g();\n"
+ "}",
+ Style);
+
+ verifyFormat("while(a) {\n"
+ " f();\n"
+ "}",
+ Style);
+
+ verifyFormat("do {\n"
+ " f();\n"
+ "} while(0)",
+ Style);
+
+ verifyFormat("for(int i = 0; i < size(); i++) {\n"
+ " f();\n"
+ "}",
+ Style);
+}
+
} // end namespace
} // end namespace format
} // end namespace clang
Index: clang/lib/Format/TokenAnnotator.cpp
===================================================================
--- clang/lib/Format/TokenAnnotator.cpp
+++ clang/lib/Format/TokenAnnotator.cpp
@@ -2679,6 +2679,16 @@
Right.MatchingParen->endsSequence(TT_DictLiteral, tok::at))
// Objective-C dictionary literal -> no space before closing brace.
return false;
+ // Do we want a space between ) and {
+ if (Right.is(tok::l_brace) && Left.is(tok::r_paren))
+ return Style.SpaceAroundBraces;
+ // Do we want a space between } and else
+ if (Left.is(tok::r_brace) && Right.isOneOf(tok::kw_else, tok::kw_while))
+ return Style.SpaceAroundBraces;
+ // Do we want a space between do,while,else {
+ if (Right.is(tok::l_brace) &&
+ Left.isOneOf(tok::kw_do, tok::kw_while, tok::kw_else))
+ return Style.SpaceAroundBraces;
return true;
}
Index: clang/lib/Format/Format.cpp
===================================================================
--- clang/lib/Format/Format.cpp
+++ clang/lib/Format/Format.cpp
@@ -494,6 +494,7 @@
IO.mapOptional("SpaceAfterLogicalNot", Style.SpaceAfterLogicalNot);
IO.mapOptional("SpaceAfterTemplateKeyword",
Style.SpaceAfterTemplateKeyword);
+ IO.mapOptional("SpaceAroundBraces", Style.SpaceAroundBraces);
IO.mapOptional("SpaceBeforeAssignmentOperators",
Style.SpaceBeforeAssignmentOperators);
IO.mapOptional("SpaceBeforeCpp11BracedList",
@@ -745,6 +746,7 @@
LLVMStyle.Standard = FormatStyle::LS_Cpp11;
LLVMStyle.UseTab = FormatStyle::UT_Never;
LLVMStyle.ReflowComments = true;
+ LLVMStyle.SpaceAroundBraces = true;
LLVMStyle.SpacesInParentheses = false;
LLVMStyle.SpacesInSquareBrackets = false;
LLVMStyle.SpaceInEmptyBlock = false;
Index: clang/include/clang/Format/Format.h
===================================================================
--- clang/include/clang/Format/Format.h
+++ clang/include/clang/Format/Format.h
@@ -489,38 +489,38 @@
/// Different ways to break after the template declaration.
enum BreakTemplateDeclarationsStyle {
- /// Do not force break before declaration.
- /// ``PenaltyBreakTemplateDeclaration`` is taken into account.
- /// \code
- /// template <typename T> T foo() {
- /// }
- /// template <typename T> T foo(int aaaaaaaaaaaaaaaaaaaaa,
- /// int bbbbbbbbbbbbbbbbbbbbb) {
- /// }
- /// \endcode
- BTDS_No,
- /// Force break after template declaration only when the following
- /// declaration spans multiple lines.
- /// \code
- /// template <typename T> T foo() {
- /// }
- /// template <typename T>
- /// T foo(int aaaaaaaaaaaaaaaaaaaaa,
- /// int bbbbbbbbbbbbbbbbbbbbb) {
- /// }
- /// \endcode
- BTDS_MultiLine,
- /// Always break after template declaration.
- /// \code
- /// template <typename T>
- /// T foo() {
- /// }
- /// template <typename T>
- /// T foo(int aaaaaaaaaaaaaaaaaaaaa,
- /// int bbbbbbbbbbbbbbbbbbbbb) {
- /// }
- /// \endcode
- BTDS_Yes
+ /// Do not force break before declaration.
+ /// ``PenaltyBreakTemplateDeclaration`` is taken into account.
+ /// \code
+ /// template <typename T> T foo() {
+ /// }
+ /// template <typename T> T foo(int aaaaaaaaaaaaaaaaaaaaa,
+ /// int bbbbbbbbbbbbbbbbbbbbb) {
+ /// }
+ /// \endcode
+ BTDS_No,
+ /// Force break after template declaration only when the following
+ /// declaration spans multiple lines.
+ /// \code
+ /// template <typename T> T foo() {
+ /// }
+ /// template <typename T>
+ /// T foo(int aaaaaaaaaaaaaaaaaaaaa,
+ /// int bbbbbbbbbbbbbbbbbbbbb) {
+ /// }
+ /// \endcode
+ BTDS_MultiLine,
+ /// Always break after template declaration.
+ /// \code
+ /// template <typename T>
+ /// T foo() {
+ /// }
+ /// template <typename T>
+ /// T foo(int aaaaaaaaaaaaaaaaaaaaa,
+ /// int bbbbbbbbbbbbbbbbbbbbb) {
+ /// }
+ /// \endcode
+ BTDS_Yes
};
/// The template declaration breaking style to use.
@@ -1751,6 +1751,15 @@
/// \endcode
bool SpaceAfterTemplateKeyword;
+ /// If ``true``, a space is inserted before and after a brace.
+ /// \code
+ /// true: false:
+ /// if (x) {} vs. if (x){}
+ /// } else if (y) {} vs. }else if (y){}
+ /// } else {} vs. }else{}
+ /// \endcode
+ bool SpaceAroundBraces;
+
/// If ``false``, spaces will be removed before assignment operators.
/// \code
/// true: false:
Index: clang/docs/ClangFormatStyleOptions.rst
===================================================================
--- clang/docs/ClangFormatStyleOptions.rst
+++ clang/docs/ClangFormatStyleOptions.rst
@@ -2061,6 +2061,16 @@
true: false:
template <int> void foo(); vs. template<int> void foo();
+**SpaceAroundBraces** (``bool``)
+ If ``true``, a space is inserted before and after a brace.
+
+ .. code-block:: c++
+
+ true: false:
+ if (x) {} vs. if (x){}
+ } else if (y) {} vs. }else if (y){}
+ } else {} vs. }else{}
+
**SpaceBeforeAssignmentOperators** (``bool``)
If ``false``, spaces will be removed before assignment operators.
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
