[clang-format] Adds space around braces in text protos

[krasimir]

Summary

This patch modifies the text proto Google style to add spaces around braces.

I investigated using something different than Cpp11BracedListStyle, but it turns out it's what we want and also the java and js styles also depend on that.

[djasper]

Looks good.

lib/Format/Format.cpp

if (Language == FormatStyle::LK_Java) {
     GoogleStyle.MaxEmptyLinesToKeep = 3;
     GoogleStyle.NamespaceIndentation = FormatStyle::NI_All;
     GoogleStyle.SpacesInContainerLiterals = false;
     GoogleStyle.JavaScriptQuotes = FormatStyle::JSQS_Single;
     GoogleStyle.JavaScriptWrapImports = false;
   } else if (Language == FormatStyle::LK_Proto) {
     GoogleStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
     GoogleStyle.SpacesInContainerLiterals = false;
+    GoogleStyle.Cpp11BracedListStyle = false;
   } else if (Language == FormatStyle::LK_ObjC) {
     GoogleStyle.ColumnLimit = 100;
   }
 
   return GoogleStyle;
 }
 
 FormatStyle getChromiumStyle(FormatStyle::LanguageKind Language) {

unittests/Format/FormatTestProto.cpp

 
 TEST_F(FormatTestProto, FormatsEnums) {
   verifyFormat("enum Type {\n"
                "  UNKNOWN = 0;\n"
                "  TYPE_A = 1;\n"
                "  TYPE_B = 2;\n"
                "};");
   verifyFormat("enum Type {\n"
-               "  UNKNOWN = 0 [(some_options) = {a: aa, b: bb}];\n"
+               "  UNKNOWN = 0 [(some_options) = { a: aa, b: bb }];\n"
                "};");
   verifyFormat("enum Type {\n"
                "  UNKNOWN = 0 [(some_options) = {\n"
                "    a: aa,  // wrap\n"
                "    b: bb\n"
                "  }];\n"
                "};");
 }
 
 TEST_F(FormatTestProto, UnderstandsReturns) {
   verifyFormat("rpc Search(SearchRequest) returns (SearchResponse);");
 }
 
 TEST_F(FormatTestProto, MessageFieldAttributes) {
   verifyFormat("optional string test = 1 [default = \"test\"];");
   verifyFormat("optional bool a = 1 [default = true, deprecated = true];");
   verifyFormat("optional LongMessageType long_proto_field = 1 [\n"
                "  default = REALLY_REALLY_LONG_CONSTANT_VALUE,\n"
                "  deprecated = true\n"
                "];");
   verifyFormat("optional LongMessageType long_proto_field = 1\n"
                "    [default = REALLY_REALLY_LONG_CONSTANT_VALUE];");
   verifyFormat("repeated double value = 1\n"
-               "    [(aaaaaaa.aaaaaaaaa) = {aaaaaaaaaaaaaaaaa: AAAAAAAA}];");
+               "    [(aaaaaaa.aaaaaaaaa) = { aaaaaaaaaaaaaaaaa: AAAAAAAA }];");
   verifyFormat("repeated double value = 1 [(aaaaaaa.aaaaaaaaa) = {\n"
                "  aaaaaaaaaaaaaaaa: AAAAAAAAAA,\n"
                "  bbbbbbbbbbbbbbbb: BBBBBBBBBB\n"
                "}];");
   verifyFormat("repeated double value = 1 [(aaaaaaa.aaaaaaaaa) = {\n"
                "  aaaaaaaaaaaaaaaa: AAAAAAAAAA\n"
                "  bbbbbbbbbbbbbbbb: BBBBBBBBBB\n"
                "}];");
EXPECT_EQ(
              "\"some.really.long.package.that.exceeds.the.column.limit\";"));
 }
 
 TEST_F(FormatTestProto, FormatsOptions) {
   verifyFormat("option (MyProto.options) = {\n"
                "  field_a: OK\n"
                "  field_b: \"OK\"\n"
                "  field_c: \"OK\"\n"
-               "  msg_field: {field_d: 123}\n"
+               "  msg_field: { field_d: 123 }\n"
                "};");
   verifyFormat("option (MyProto.options) = {\n"
                "  field_a: OK\n"
                "  field_b: \"OK\"\n"
                "  field_c: \"OK\"\n"
-               "  msg_field: {field_d: 123 field_e: OK}\n"
+               "  msg_field: { field_d: 123 field_e: OK }\n"
                "};");
   verifyFormat("option (MyProto.options) = {\n"
                "  field_a: OK  // Comment\n"
                "  field_b: \"OK\"\n"
                "  field_c: \"OK\"\n"
-               "  msg_field: {field_d: 123}\n"
+               "  msg_field: { field_d: 123 }\n"
                "};");
   verifyFormat("option (MyProto.options) = {\n"
                "  field_c: \"OK\"\n"
-               "  msg_field {field_d: 123}\n"
+               "  msg_field { field_d: 123 }\n"
                "};");
   verifyFormat("option (MyProto.options) = {\n"
                "  field_a: OK\n"
-               "  field_b {field_c: OK}\n"
+               "  field_b { field_c: OK }\n"
                "  field_d: OKOKOK\n"
                "  field_e: OK\n"
                "}");
 
   // Support syntax with <> instead of {}.
   verifyFormat("option (MyProto.options) = {\n"
                "  field_c: \"OK\",\n"
                "  msg_field: <field_d: 123>\n"
verifyFormat("option (MyProto.options) = <\n"
                "  field_b: \"OK\",\n"
                "  field_c: 1,\n"
                "  field_d: 12.5,\n"
                "  field_e: OK,\n"
                ">;");
 
   verifyFormat("option (MyProto.options) = <\n"
                "  field_a: \"OK\"\n"
-               "  msg_field: {field_b: OK}\n"
+               "  msg_field: { field_b: OK }\n"
                "  field_g: OK\n"
                "  field_g: OK\n"
                "  field_g: OK\n"
                ">;");
 
   verifyFormat("option (MyProto.options) = <\n"
                "  field_a: \"OK\"\n"
                "  msg_field <\n"
verifyFormat("option (MyProto.options) = <\n"
                "    field_e: OK\n"
                "    field_f: OK\n"
                "  }\n"
                "  field_g: OK\n"
                ">;");
 
   verifyFormat("option (MyProto.options) = <\n"
                "  data1 <key1: value1>\n"
-               "  data2 {key2: value2}\n"
+               "  data2 { key2: value2 }\n"
                ">;");
 
   verifyFormat("option (MyProto.options) = <\n"
                "  app_id: 'com.javax.swing.salsa.latino'\n"
                "  head_id: 1\n"
                "  data <key: value>\n"
                ">;");
 
   verifyFormat("option (MyProto.options) = {\n"
                "  app_id: 'com.javax.swing.salsa.latino'\n"
                "  head_id: 1\n"
                "  headheadheadheadheadhead_id: 1\n"
-               "  product_data {product {1}}\n"
+               "  product_data { product { 1 } }\n"
                "};");
 }
 
 TEST_F(FormatTestProto, FormatsService) {
   verifyFormat("service SearchService {\n"
                "  rpc Search(SearchRequest) returns (SearchResponse) {\n"
                "    option foo = true;\n"
                "  }\n"

unittests/Format/FormatTestRawStrings.cpp

expect_eq(
           R"test(P p = TP(R"pb(  item_1 :  1   )pb");)test",
           getRawStringPbStyleWithColumns(40)));
   expect_eq(
       R"test(P p = TP(R"pb(item_1: 1 item_2: 2)pb");)test",
       format(
           R"test(P p = TP(R"pb(item_1:1 item_2:2)pb");)test",
           getRawStringPbStyleWithColumns(40)));
   expect_eq(
-      R"test(P p = TP(R"pb(item_1 <1> item_2: {2})pb");)test",
+      R"test(P p = TP(R"pb(item_1 <1> item_2: { 2 })pb");)test",
       format(
           R"test(P p = TP(R"pb(item_1<1> item_2:{2})pb");)test",
           getRawStringPbStyleWithColumns(40)));
 
   // Merge two short lines into one.
   expect_eq(R"test(
 std::string s = R"pb(
   item_1: 1 item_2: 2
P p = TP(R"pb(item_1: 1,
       format(
           R"test(
 P p = TP(R"pb(item_1: 1, item_2: 2, item_3: 3, item_4: 4)pb");)test",
           getRawStringPbStyleWithColumns(40)));
 
   expect_eq(R"test(
 P p = TPPPPPPPPPPPPPPP(
     R"pb(item_1 <1>,
-         item_2: {2},
+         item_2: { 2 },
          item_3: <3>,
-         item_4: {4})pb");)test",
+         item_4: { 4 })pb");)test",
             format(R"test(
 P p = TPPPPPPPPPPPPPPP(R"pb(item_1<1>, item_2: {2}, item_3: <3>, item_4:{4})pb");)test",
                    getRawStringPbStyleWithColumns(40)));
 
   // Breaks before a short raw string exceeding the column limit.
   expect_eq(R"test(
 FFFFFFFFFFFFFFFFFFFFFFFFFFF(
     R"pb(key: 1)pb");
if (s.empty())
     P p = TPPPPPPPPPPPPPPPPPPPP(R"pb(i: 1, j:2)pb");
 }
 )test",
                    getRawStringPbStyleWithColumns(40)));
 }
 
 TEST_F(FormatTestRawStrings, FormatsRawStringArguments) {
   expect_eq(R"test(
-P p = TP(R"pb(key {1})pb", param_2);)test",
+P p = TP(R"pb(key { 1 })pb", param_2);)test",
             format(R"test(
 P p = TP(R"pb(key{1})pb",param_2);)test",
                    getRawStringPbStyleWithColumns(40)));
 
   expect_eq(R"test(
 PPPPPPPPPPPPP(R"pb(keykeyk)pb",
               param_2);)test",
             format(R"test(
 PPPPPPPPPPPPP(R"pb(keykeyk)pb", param_2);)test",
                    getRawStringPbStyleWithColumns(40)));
 
   expect_eq(R"test(
-P p =
-    TP(R"pb(item: {i: 1, s: 's'}
-            item: {i: 2, s: 't'})pb");)test",
+P p = TP(
+    R"pb(item: { i: 1, s: 's' }
+         item: { i: 2, s: 't' })pb");)test",
             format(R"test(
 P p = TP(R"pb(item: {i: 1, s: 's'} item: {i: 2, s: 't'})pb");)test",
                    getRawStringPbStyleWithColumns(40)));
   expect_eq(R"test(
 FFFFFFFFFFFFFFFFFFF(
     R"pb(key: "value")pb",
     R"pb(key2: "value")pb");)test",
             format(R"test(

unittests/Format/FormatTestTextProto.cpp

 
 TEST_F(FormatTestTextProto, KeepsTopLevelEntriesFittingALine) {
   verifyFormat("field_a: OK field_b: OK field_c: OK field_d: OK field_e: OK");
 }
 
 TEST_F(FormatTestTextProto, SupportsMessageFields) {
   verifyFormat("msg_field: {}");
 
-  verifyFormat("msg_field: {field_a: A}");
+  verifyFormat("msg_field: { field_a: A }");
 
-  verifyFormat("msg_field: {field_a: \"OK\" field_b: 123}");
+  verifyFormat("msg_field: { field_a: \"OK\" field_b: 123 }");
 
   verifyFormat("msg_field: {\n"
                "  field_a: 1\n"
                "  field_b: OK\n"
                "  field_c: \"OK\"\n"
                "  field_d: 123\n"
                "  field_e: 23\n"
                "}");
 
   verifyFormat("msg_field {}");
 
-  verifyFormat("msg_field {field_a: A}");
+  verifyFormat("msg_field { field_a: A }");
 
-  verifyFormat("msg_field {field_a: \"OK\" field_b: 123}");
+  verifyFormat("msg_field { field_a: \"OK\" field_b: 123 }");
 
   verifyFormat("msg_field {\n"
                "  field_a: 1\n"
                "  field_b: OK\n"
                "  field_c: \"OK\"\n"
                "  field_d: 123\n"
                "  field_e: 23.0\n"
                "  field_f: false\n"
                "  field_g: 'lala'\n"
                "  field_h: 1234.567e-89\n"
                "}");
 
-  verifyFormat("msg_field: {msg_field {field_a: 1}}");
+  verifyFormat("msg_field: { msg_field { field_a: 1 } }");
 
   verifyFormat("id: \"ala.bala\"\n"
-               "item {type: ITEM_A rank: 1 score: 90.0}\n"
-               "item {type: ITEM_B rank: 2 score: 70.5}\n"
+               "item { type: ITEM_A rank: 1 score: 90.0 }\n"
+               "item { type: ITEM_B rank: 2 score: 70.5 }\n"
                "item {\n"
                "  type: ITEM_A\n"
                "  rank: 3\n"
                "  score: 20.0\n"
                "  description: \"the third item has a description\"\n"
                "}");
 }
 
 TEST_F(FormatTestTextProto, AvoidsTopLevelBinPacking) {
   verifyFormat("field_a: OK\n"
                "field_b: OK\n"
                "field_c: OK\n"
                "field_d: OK\n"
                "field_e: OK\n"
                "field_f: OK");
 
   verifyFormat("field_a: OK\n"
                "field_b: \"OK\"\n"
                "field_c: \"OK\"\n"
-               "msg_field: {field_d: 123}\n"
+               "msg_field: { field_d: 123 }\n"
                "field_e: OK\n"
                "field_f: OK");
 
   verifyFormat("field_a: OK\n"
                "field_b: \"OK\"\n"
                "field_c: \"OK\"\n"
-               "msg_field: {field_d: 123 field_e: OK}");
+               "msg_field: { field_d: 123 field_e: OK }");
 
   verifyFormat("a: {\n"
                "  field_a: OK\n"
-               "  field_b {field_c: OK}\n"
+               "  field_b { field_c: OK }\n"
                "  field_d: OKOKOK\n"
                "  field_e: OK\n"
                "}");
 
   verifyFormat("field_a: OK,\n"
-               "field_b {field_c: OK},\n"
+               "field_b { field_c: OK },\n"
                "field_d: OKOKOK,\n"
                "field_e: OK");
 }
 
 TEST_F(FormatTestTextProto, AddsNewlinesAfterTrailingComments) {
   verifyFormat("field_a: OK  // Comment\n"
                "field_b: 1");
 
TEST_F(FormatTestTextProto, SupportsAngleBracketMessageFields) {
   verifyFormat("msg_field: <>");
   verifyFormat("msg_field <field_a: OK>");
   verifyFormat("msg_field: <field_a: 123>");
   verifyFormat("msg_field <field_a <>>");
   verifyFormat("msg_field <field_a <field_b <>>>");
   verifyFormat("msg_field: <field_a <field_b: <>>>");
   verifyFormat("msg_field <field_a: OK, field_b: \"OK\">");
   verifyFormat("msg_field <field_a: OK field_b: <>, field_c: OK>");
-  verifyFormat("msg_field <field_a {field_b: 1}, field_c: <field_d: 2>>");
+  verifyFormat("msg_field <field_a { field_b: 1 }, field_c: <field_d: 2>>");
   verifyFormat("msg_field: <field_a: OK, field_b: \"OK\">");
   verifyFormat("msg_field: <field_a: OK field_b: <>, field_c: OK>");
-  verifyFormat("msg_field: <field_a {field_b: 1}, field_c: <field_d: 2>>");
+  verifyFormat("msg_field: <field_a { field_b: 1 }, field_c: <field_d: 2>>");
   verifyFormat("field_a: \"OK\", msg_field: <field_b: 123>, field_c: {}");
   verifyFormat("field_a <field_b: 1>, msg_field: <field_b: 123>, field_c <>");
   verifyFormat("field_a <field_b: 1> msg_field: <field_b: 123> field_c <>");
   verifyFormat("field <field <field: <>>, field <>> field: <field: 1>");
 
   // Multiple lines tests
   verifyFormat("msg_field <\n"
                "  field_a: OK\n"
verifyFormat("msg_field <\n"
                "  field_a: <field: OK>,\n"
                "  field_b <field_c: OK>,\n"
                "  field_d: <12.5>,\n"
                "  field_e: OK,\n"
                ">");
 
   verifyFormat("msg_field: <\n"
                "  field_a: \"OK\"\n"
-               "  msg_field: {field_b: OK}\n"
+               "  msg_field: { field_b: OK }\n"
                "  field_g: OK\n"
                "  field_g: OK\n"
                "  field_g: OK\n"
                ">");
 
   verifyFormat("field_a {\n"
                "  field_d: ok\n"
                "  field_b: <field_c: 1>\n"
verifyFormat("field_a: {\n"
                "}");
 
   verifyFormat("field_a: <f1: 1, f2: <>>\n"
                "field_b <\n"
                "  field_b1: <>\n"
                "  field_b2: ok,\n"
                "  field_b3: <\n"
                "    field_x {}  // Comment\n"
-               "    field_y: {field_z: 1}\n"
+               "    field_y: { field_z: 1 }\n"
                "    field_w: ok\n"
                "  >\n"
                "  field {\n"
                "    field_x <>  // Comment\n"
                "    field_y: <field_z: 1>\n"
                "    field_w: ok\n"
                "    msg_field: <\n"
                "      field: <>\n"
TEST_F(FormatTestTextProto, SupportsAngleBracketMessageFields) {
   verifyFormat("app_id: 'com.javax.swing.salsa.latino'\n"
                "head_id: 1\n"
                "data <key: value>\n"
                "tail_id: 2");
 
   verifyFormat("app_id: 'com.javax.swing.salsa.latino'\n"
                "head_id: 1\n"
                "data <key: value>\n"
-               "data {key: value}");
+               "data { key: value }");
 
   verifyFormat("app {\n"
                "  app_id: 'com.javax.swing.salsa.latino'\n"
                "  head_id: 1\n"
                "  data <key: value>\n"
                "}");
 
   verifyFormat("app: {\n"
                "  app_id: 'com.javax.swing.salsa.latino'\n"
                "  head_id: 1\n"
                "  data <key: value>\n"
                "}");
 
   verifyFormat("app_id: 'com.javax.swing.salsa.latino'\n"
                "headheadheadheadheadhead_id: 1\n"
-               "product_data {product {1}}");
+               "product_data { product { 1 } }");
 
   verifyFormat("app_id: 'com.javax.swing.salsa.latino'\n"
                "headheadheadheadheadhead_id: 1\n"
-               "product_data <product {1}>");
+               "product_data <product { 1 }>");
 
   verifyFormat("app_id: 'com.javax.swing.salsa.latino'\n"
                "headheadheadheadheadhead_id: 1\n"
                "product_data <product <1>>");
 
   verifyFormat("app <\n"
                "  app_id: 'com.javax.swing.salsa.latino'\n"
                "  headheadheadheadheadhead_id: 1\n"
-               "  product_data <product {1}>\n"
+               "  product_data <product { 1 }>\n"
                ">");
 
   verifyFormat("dcccwrnfioeruvginerurneitinfo {\n"
-               "  exte3nsionrnfvui {key: value}\n"
+               "  exte3nsionrnfvui { key: value }\n"
                "}");
 }
 
 TEST_F(FormatTestTextProto, DiscardsUnbreakableTailIfCanBreakAfter) {
   // The two closing braces count towards the string UnbreakableTailLength, but
   // since we have broken after the corresponding opening braces, we don't
   // consider that length for string breaking.
   verifyFormat(
       "foo: {\n"
       "  bar: {\n"
       "    text: \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"\n"
       "  }\n"
       "}");
 }
 } // end namespace tooling
 } // end namespace clang