This is an archive of the discontinued LLVM Phabricator instance.

Differential D46757

[clang-format] text protos: put entries on separate lines if there is a submessage
ClosedPublic

Authored by krasimir on May 11 2018, 7:37 AM.

Details

Reviewers
sammccall
Commits
rG8b98f5517f24: [clang-format] text protos: put entries on separate lines if there is a…
rL334401: [clang-format] text protos: put entries on separate lines if there is a…
rC334401: [clang-format] text protos: put entries on separate lines if there is a…
Summary

This patch updates clang-format text protos to put entries of a submessage into separate lines if the submessage contains at least two entries and contains at least one submessage entry.

For example, the entries here are kept on separate lines even if putting them on a single line would be under the column limit:

message: {
  entry: 1
  submessage: { key: value }
}

Messages containing a single submessage or several scalar entries can still be put on one line if they fit:

message { submessage { key: value } }
message { x: 1 y: 2 z: 3 }

Diff Detail

Repository
rC Clang

Event Timeline

krasimir created this revision.May 11 2018, 7:37 AM
Herald added subscribers: cfe-commits, klimek. · View Herald TranscriptMay 11 2018, 7:37 AM
Harbormaster completed remote builds in B17991: Diff 146327.May 11 2018, 7:37 AM
krasimir updated this revision to Diff 150273.Jun 7 2018, 1:18 AM
  • Polish
Harbormaster completed remote builds in B19036: Diff 150273.Jun 7 2018, 1:19 AM
krasimir updated this revision to Diff 150317.Jun 7 2018, 6:35 AM
  • Update comments
krasimir updated this revision to Diff 150320.Jun 7 2018, 6:41 AM
  • Add comments tests
Harbormaster completed remote builds in B19048: Diff 150320.Jun 7 2018, 6:41 AM
krasimir retitled this revision from [clang-format] Break inside submessages containing a submessage and something else to [clang-format] text protos: put entries on separate lines if there is a submessage.Jun 7 2018, 6:46 AM
krasimir edited the summary of this revision. (Show Details)
krasimir edited the summary of this revision. (Show Details)
krasimir added a reviewer: sammccall.
sammccall accepted this revision.Jun 11 2018, 4:37 AM

LG

lib/Format/TokenAnnotator.cpp
2942

One more high-level piece could be added to this comment, e.g.

// We enforce this by breaking before a submessage field that has previous siblings, *and*
// breaking before a field that follows a submessage field.
2943

nit: the ] is the TT_SelectorName

2944

This could be slightly clearer I think...

... but we don't want to break inside the brackets. We ensure elsewhere that extensions are always on their own line.
2953

nit: this can't be a paren. calling it "brace" is probably ok

2983

nit: preceded

This revision is now accepted and ready to land.Jun 11 2018, 4:37 AM
krasimir updated this revision to Diff 150730.Jun 11 2018, 5:56 AM
krasimir marked 5 inline comments as done.
  • Address review comments
Harbormaster completed remote builds in B19165: Diff 150730.Jun 11 2018, 5:56 AM
Closed by commit rC334401: [clang-format] text protos: put entries on separate lines if there is a… (authored by krasimir). · Explain WhyJun 11 2018, 5:57 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
lib/
Format/
68 lines
unittests/
Format/
131 lines
18 lines
161 lines

Diff 150731

lib/Format/TokenAnnotator.cpp

Show First 20 Lines • Show All 2,918 Lines • ▼ Show 20 Lines if ((Style.Language == FormatStyle::LK_Java ||
Left.is(TT_LeadingJavaAnnotation) && Left.is(TT_LeadingJavaAnnotation) &&
Right.isNot(TT_LeadingJavaAnnotation) && Right.isNot(tok::l_paren) && Right.isNot(TT_LeadingJavaAnnotation) && Right.isNot(tok::l_paren) &&
(Line.Last->is(tok::l_brace) || Style.BreakAfterJavaFieldAnnotations)) (Line.Last->is(tok::l_brace) || Style.BreakAfterJavaFieldAnnotations))
return true; return true;
if (Right.is(TT_ProtoExtensionLSquare)) if (Right.is(TT_ProtoExtensionLSquare))
return true; return true;
// In text proto instances if a submessage contains at least 2 entries and at
// least one of them is a submessage, like A { ... B { ... } ... },
// put all of the entries of A on separate lines by forcing the selector of
// the submessage B to be put on a newline.
//
// Example: these can stay on one line:
// a { scalar_1: 1 scalar_2: 2 }
// a { b { key: value } }
//
// and these entries need to be on a new line even if putting them all in one
// line is under the column limit:
// a {
// scalar: 1
// b { key: value }
// }
//
sammccallUnsubmitted
Done
ReplyInline Actions

One more high-level piece could be added to this comment, e.g.

// We enforce this by breaking before a submessage field that has previous siblings, *and*
// breaking before a field that follows a submessage field.
sammccall: One more high-level piece could be added to this comment, e.g. ``` // We enforce this by…
// We enforce this by breaking before a submessage field that has previous
sammccallUnsubmitted
Done
ReplyInline Actions

nit: the ] is the TT_SelectorName

sammccall: nit: the `]` is **the** TT_SelectorName
// siblings, *and* breaking before a field that follows a submessage field.
sammccallUnsubmitted
Done
ReplyInline Actions

This could be slightly clearer I think...

... but we don't want to break inside the brackets. We ensure elsewhere that extensions are always on their own line.
sammccall: This could be slightly clearer I think... ```... but we don't want to break inside the…
//
// Be careful to exclude the case [proto.ext] { ... } since the `]` is
// the TT_SelectorName there, but we don't want to break inside the brackets.
// We ensure elsewhere that extensions are always on their own line.
if ((Style.Language == FormatStyle::LK_Proto ||
Style.Language == FormatStyle::LK_TextProto) &&
Right.is(TT_SelectorName) && !Right.is(tok::r_square) && Right.Next) {
// Look for the scope opener after selector in cases like:
// selector { ...
sammccallUnsubmitted
Done
ReplyInline Actions

nit: this can't be a paren. calling it "brace" is probably ok

sammccall: nit: this can't be a paren. calling it "brace" is probably ok
// selector: { ...
FormatToken *LBrace =
Right.Next->is(tok::colon) ? Right.Next->Next : Right.Next;
if (LBrace &&
// The scope opener is one of {, [, <:
// selector { ... }
// selector [ ... ]
// selector < ... >
//
// In case of selector { ... }, the l_brace is TT_DictLiteral.
// In case of an empty selector {}, the l_brace is not TT_DictLiteral,
// so we check for immediately following r_brace.
((LBrace->is(tok::l_brace) &&
(LBrace->is(TT_DictLiteral) ||
(LBrace->Next && LBrace->Next->is(tok::r_brace)))) ||
LBrace->is(TT_ArrayInitializerLSquare) || LBrace->is(tok::less))) {
// If Left.ParameterCount is 0, then this submessage entry is not the
// first in its parent submessage, and we want to break before this entry.
// If Left.ParameterCount is greater than 0, then its parent submessage
// might contain 1 or more entries and we want to break before this entry
// if it contains at least 2 entries. We deal with this case later by
// detecting and breaking before the next entry in the parent submessage.
if (Left.ParameterCount == 0)
return true;
// However, if this submessage is the first entry in its parent
// submessage, Left.ParameterCount might be 1 in some cases.
// We deal with this case later by detecting an entry
// following a closing paren of this submessage.
}
sammccallUnsubmitted
Done
ReplyInline Actions

nit: preceded

sammccall: nit: preceded
// If this is an entry immediately following a submessage, it will be
// preceded by a closing paren of that submessage, like in:
// left---. .---right
// v v
// sub: { ... } key: value
// If there was a comment between `}` an `key` above, then `key` would be
// put on a new line anyways.
if (Left.isOneOf(tok::r_brace, tok::greater, tok::r_square))
return true;
}
return false; return false;
} }
bool TokenAnnotator::canBreakBefore(const AnnotatedLine &Line, bool TokenAnnotator::canBreakBefore(const AnnotatedLine &Line,
const FormatToken &Right) { const FormatToken &Right) {
const FormatToken &Left = *Right.Previous; const FormatToken &Left = *Right.Previous;
// Language-specific stuff. // Language-specific stuff.
▲ Show 20 Lines • Show All 236 Lines • Show Last 20 Lines

unittests/Format/FormatTestProto.cpp

Show First 20 Lines • Show All 487 Lines • ▼ Show 20 Lines verifyFormat("option (MyProto.options) = {\n"
" operator: 2\n" " operator: 2\n"
" operator: 3\n" " operator: 3\n"
" operator { key: value }\n" " operator { key: value }\n"
" >\n" " >\n"
" >\n" " >\n"
"};"); "};");
} }
TEST_F(FormatTestProto, BreaksEntriesOfSubmessagesContainingSubmessages) {
FormatStyle Style = getGoogleStyle(FormatStyle::LK_TextProto);
Style.ColumnLimit = 60;
// The column limit allows for the keys submessage to be put on 1 line, but we
// break it since it contains a submessage an another entry.
verifyFormat("option (MyProto.options) = {\n"
" key: valueeeeeeee\n"
" keys: {\n"
" item: 'aaaaaaaaaaaaaaaa'\n"
" sub <>\n"
" }\n"
"}");
verifyFormat("option (MyProto.options) = {\n"
" key: valueeeeeeee\n"
" keys: {\n"
" item: 'aaaaaaaaaaaaaaaa'\n"
" sub {}\n"
" }\n"
"}");
verifyFormat("option (MyProto.options) = {\n"
" key: valueeeeeeee\n"
" keys: {\n"
" sub {}\n"
" sub: <>\n"
" sub: []\n"
" }\n"
"}");
verifyFormat("option (MyProto.options) = {\n"
" key: valueeeeeeee\n"
" keys: {\n"
" item: 'aaaaaaaaaaa'\n"
" sub { msg: 1 }\n"
" }\n"
"}");
verifyFormat("option (MyProto.options) = {\n"
" key: valueeeeeeee\n"
" keys: {\n"
" item: 'aaaaaaaaaaa'\n"
" sub: { msg: 1 }\n"
" }\n"
"}");
verifyFormat("option (MyProto.options) = {\n"
" key: valueeeeeeee\n"
" keys: {\n"
" item: 'aaaaaaaaaaa'\n"
" sub < msg: 1 >\n"
" }\n"
"}");
verifyFormat("option (MyProto.options) = {\n"
" key: valueeeeeeee\n"
" keys: {\n"
" item: 'aaaaaaaaaaa'\n"
" sub: [ msg: 1 ]\n"
" }\n"
"}");
verifyFormat("option (MyProto.options) = {\n"
" key: valueeeeeeee\n"
" keys: <\n"
" item: 'aaaaaaaaaaa'\n"
" sub: [ 1, 2 ]\n"
" >\n"
"}");
verifyFormat("option (MyProto.options) = {\n"
" key: valueeeeeeee\n"
" keys: {\n"
" sub {}\n"
" item: 'aaaaaaaaaaaaaaaa'\n"
" }\n"
"}");
verifyFormat("option (MyProto.options) = {\n"
" key: valueeeeeeee\n"
" keys: {\n"
" sub: []\n"
" item: 'aaaaaaaaaaaaaaaa'\n"
" }\n"
"}");
verifyFormat("option (MyProto.options) = {\n"
" key: valueeeeeeee\n"
" keys: {\n"
" sub <>\n"
" item: 'aaaaaaaaaaaaaaaa'\n"
" }\n"
"}");
verifyFormat("option (MyProto.options) = {\n"
" key: valueeeeeeee\n"
" keys: {\n"
" sub { key: value }\n"
" item: 'aaaaaaaaaaaaaaaa'\n"
" }\n"
"}");
verifyFormat("option (MyProto.options) = {\n"
" key: valueeeeeeee\n"
" keys: {\n"
" sub: [ 1, 2 ]\n"
" item: 'aaaaaaaaaaaaaaaa'\n"
" }\n"
"}");
verifyFormat("option (MyProto.options) = {\n"
" key: valueeeeeeee\n"
" keys: {\n"
" sub < sub_2: {} >\n"
" item: 'aaaaaaaaaaaaaaaa'\n"
" }\n"
"}");
verifyFormat("option (MyProto.options) = {\n"
" key: valueeeeeeee\n"
" keys: {\n"
" item: data\n"
" sub: [ 1, 2 ]\n"
" item: 'aaaaaaaaaaaaaaaa'\n"
" }\n"
"}");
verifyFormat("option (MyProto.options) = {\n"
" key: valueeeeeeee\n"
" keys: {\n"
" item: data\n"
" sub < sub_2: {} >\n"
" item: 'aaaaaaaaaaaaaaaa'\n"
" }\n"
"}");
verifyFormat("option (MyProto.options) = {\n"
" sub: {\n"
" key: valueeeeeeee\n"
" keys: {\n"
" sub: [ 1, 2 ]\n"
" item: 'aaaaaaaaaaaaaaaa'\n"
" }\n"
" }\n"
"}");
}
} // end namespace tooling } // end namespace tooling
} // end namespace clang } // end namespace clang

unittests/Format/FormatTestRawStrings.cpp

Show First 20 Lines • Show All 193 Lines • ▼ Show 20 Lines expect_eq(
format( format(
R"test(P p = TP(R"pb( item_1 : 1 )pb");)test", R"test(P p = TP(R"pb( item_1 : 1 )pb");)test",
getRawStringPbStyleWithColumns(40))); getRawStringPbStyleWithColumns(40)));
expect_eq( 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( format(
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",
getRawStringPbStyleWithColumns(40))); 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)));
// Merge two short lines into one. // Merge two short lines into one.
expect_eq(R"test( expect_eq(R"test(
std::string s = R"pb( std::string s = R"pb(
item_1: 1 item_2: 2 item_1: 1 item_2: 2
)pb"; )pb";
)test", )test",
format(R"test( format(R"test(
std::string s = R"pb( std::string s = R"pb(
item_1:1 item_1:1
item_2:2 item_2:2
)pb"; )pb";
)test", )test",
getRawStringPbStyleWithColumns(40))); getRawStringPbStyleWithColumns(40)));
} }
TEST_F(FormatTestRawStrings, BreaksShortRawStringsWhenNeeded) {
// The raw string contains multiple submessage entries, so break for
// readability.
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)));
}
TEST_F(FormatTestRawStrings, BreaksRawStringsExceedingColumnLimit) { TEST_F(FormatTestRawStrings, BreaksRawStringsExceedingColumnLimit) {
expect_eq(R"test( expect_eq(R"test(
P p = TPPPPPPPPPPPPPPP( P p = TPPPPPPPPPPPPPPP(
R"pb(item_1: 1, item_2: 2)pb");)test", R"pb(item_1: 1, item_2: 2)pb");)test",
format(R"test( format(R"test(
P p = TPPPPPPPPPPPPPPP(R"pb(item_1: 1, item_2: 2)pb");)test", P p = TPPPPPPPPPPPPPPP(R"pb(item_1: 1, item_2: 2)pb");)test",
getRawStringPbStyleWithColumns(40))); getRawStringPbStyleWithColumns(40)));
▲ Show 20 Lines • Show All 632 Lines • Show Last 20 Lines

unittests/Format/FormatTestTextProto.cpp

Show First 20 Lines • Show All 165 Lines • ▼ Show 20 LinesTEST_F(FormatTestTextProto, SupportsAngleBracketMessageFields) {
verifyFormat("msg_field <>"); verifyFormat("msg_field <>");
verifyFormat("msg_field: <>"); verifyFormat("msg_field: <>");
verifyFormat("msg_field < field_a: OK >"); verifyFormat("msg_field < field_a: OK >");
verifyFormat("msg_field: < field_a: 123 >"); verifyFormat("msg_field: < field_a: 123 >");
verifyFormat("msg_field < field_a <> >"); verifyFormat("msg_field < field_a <> >");
verifyFormat("msg_field < field_a < field_b <> > >"); verifyFormat("msg_field < field_a < field_b <> > >");
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: \"OK\" >");
verifyFormat("msg_field < field_a: OK field_b: <>, field_c: OK >");
verifyFormat("msg_field < field_a { field_b: 1 }, field_c: < f_d: 2 > >");
verifyFormat("msg_field: < field_a: OK, field_b: \"OK\" >"); 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: < fd_d: 2 > >");
verifyFormat("field_a: \"OK\", msg_field: < field_b: 123 >, field_c: {}");
verifyFormat("field_a < field_b: 1 >, msg_fid: < fiel_b: 123 >, field_c <>");
verifyFormat("field_a < field_b: 1 > msg_fied: < field_b: 123 > field_c <>");
verifyFormat("field < field < field: <> >, field <> > field: < field: 1 >");
// Multiple lines tests // Multiple lines tests
verifyFormat("msg_field <\n" verifyFormat("msg_field <\n"
" field_a: OK\n" " field_a: OK\n"
" field_b: <>,\n"
" field_c: OK\n"
">");
verifyFormat("msg_field <\n"
" field_a { field_b: 1 },\n"
" field_c: < f_d: 2 >\n"
">");
verifyFormat("msg_field: <\n"
" field_a: OK\n"
" field_b: <>,\n"
" field_c: OK\n"
">");
verifyFormat("msg_field: <\n"
" field_a { field_b: 1 },\n"
" field_c: < fd_d: 2 >\n"
">");
verifyFormat("field_a: \"OK\",\n"
"msg_field: < field_b: 123 >,\n"
"field_c: {}");
verifyFormat("field_a < field_b: 1 >,\n"
"msg_fid: < fiel_b: 123 >,\n"
"field_c <>");
verifyFormat("field_a < field_b: 1 >\n"
"msg_fied: < field_b: 123 >\n"
"field_c <>");
verifyFormat("field <\n"
" field < field: <> >,\n"
" field <>\n"
">\n"
"field: < field: 1 >");
verifyFormat("msg_field <\n"
" field_a: OK\n"
" field_b: \"OK\"\n" " field_b: \"OK\"\n"
" field_c: 1\n" " field_c: 1\n"
" field_d: 12.5\n" " field_d: 12.5\n"
" field_e: OK\n" " field_e: OK\n"
">"); ">");
verifyFormat("msg_field: <>\n" verifyFormat("msg_field: <>\n"
"field_c: \"OK\",\n" "field_c: \"OK\",\n"
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 LinesTEST_F(FormatTestTextProto, SupportsAngleBracketMessageFields) {
verifyFormat("field_a: {\n" verifyFormat("field_a: {\n"
" field_d: ok\n" " field_d: ok\n"
" field_b: < field_c: 1 >\n" " field_b: < field_c: 1 >\n"
" field_d: ok\n" " field_d: ok\n"
" field_d: ok\n" " field_d: ok\n"
"}"); "}");
verifyFormat("field_a: < f1: 1, f2: <> >\n" verifyFormat("field_a: <\n"
" f1: 1,\n"
" f2: <>\n"
">\n"
"field_b <\n" "field_b <\n"
" field_b1: <>\n" " field_b1: <>\n"
" field_b2: ok,\n" " field_b2: ok,\n"
" field_b3: <\n" " field_b3: <\n"
" field_x {} // Comment\n" " field_x {} // Comment\n"
" field_y: { field_z: 1 }\n" " field_y: { field_z: 1 }\n"
" field_w: ok\n" " field_w: ok\n"
" >\n" " >\n"
▲ Show 20 Lines • Show All 270 Lines • ▼ Show 20 LinesTEST_F(FormatTestTextProto, BreaksAfterBraceFollowedByClosingBraceOnNextLine) {
verifyFormat("keys: [\n" verifyFormat("keys: [\n"
" data: { item: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' }\n" " data: { item: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' }\n"
"]"); "]");
verifyFormat("keys: <\n" verifyFormat("keys: <\n"
" data: { item: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' }\n" " data: { item: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' }\n"
">"); ">");
} }
TEST_F(FormatTestTextProto, BreaksEntriesOfSubmessagesContainingSubmessages) {
FormatStyle Style = getGoogleStyle(FormatStyle::LK_TextProto);
Style.ColumnLimit = 60;
// The column limit allows for the keys submessage to be put on 1 line, but we
// break it since it contains a submessage an another entry.
verifyFormat("key: valueeeeeeee\n"
"keys: {\n"
" item: 'aaaaaaaaaaaaaaaa'\n"
" sub <>\n"
"}");
verifyFormat("key: valueeeeeeee\n"
"keys: {\n"
" item: 'aaaaaaaaaaaaaaaa'\n"
" sub {}\n"
"}");
verifyFormat("key: valueeeeeeee\n"
"keys: {\n"
" sub {}\n"
" sub: <>\n"
" sub: []\n"
"}");
verifyFormat("key: valueeeeeeee\n"
"keys: {\n"
" item: 'aaaaaaaaaaa'\n"
" sub { msg: 1 }\n"
"}");
verifyFormat("key: valueeeeeeee\n"
"keys: {\n"
" item: 'aaaaaaaaaaa'\n"
" sub: { msg: 1 }\n"
"}");
verifyFormat("key: valueeeeeeee\n"
"keys: {\n"
" item: 'aaaaaaaaaaa'\n"
" sub < msg: 1 >\n"
"}");
verifyFormat("key: valueeeeeeee\n"
"keys: {\n"
" item: 'aaaaaaaaaaa'\n"
" sub: [ msg: 1 ]\n"
"}");
verifyFormat("key: valueeeeeeee\n"
"keys: <\n"
" item: 'aaaaaaaaaaa'\n"
" sub: [ 1, 2 ]\n"
">");
verifyFormat("key: valueeeeeeee\n"
"keys: {\n"
" sub {}\n"
" item: 'aaaaaaaaaaaaaaaa'\n"
"}");
verifyFormat("key: valueeeeeeee\n"
"keys: {\n"
" sub: []\n"
" item: 'aaaaaaaaaaaaaaaa'\n"
"}");
verifyFormat("key: valueeeeeeee\n"
"keys: {\n"
" sub <>\n"
" item: 'aaaaaaaaaaaaaaaa'\n"
"}");
verifyFormat("key: valueeeeeeee\n"
"keys: {\n"
" sub { key: value }\n"
" item: 'aaaaaaaaaaaaaaaa'\n"
"}");
verifyFormat("key: valueeeeeeee\n"
"keys: {\n"
" sub: [ 1, 2 ]\n"
" item: 'aaaaaaaaaaaaaaaa'\n"
"}");
verifyFormat("key: valueeeeeeee\n"
"keys: {\n"
" sub < sub_2: {} >\n"
" item: 'aaaaaaaaaaaaaaaa'\n"
"}");
verifyFormat("key: valueeeeeeee\n"
"keys: {\n"
" item: data\n"
" sub: [ 1, 2 ]\n"
" item: 'aaaaaaaaaaaaaaaa'\n"
"}");
verifyFormat("key: valueeeeeeee\n"
"keys: {\n"
" item: data\n"
" sub < sub_2: {} >\n"
" item: 'aaaaaaaaaaaaaaaa'\n"
"}");
verifyFormat("sub: {\n"
" key: valueeeeeeee\n"
" keys: {\n"
" sub: [ 1, 2 ]\n"
" item: 'aaaaaaaaaaaaaaaa'\n"
" }\n"
"}");
verifyFormat("sub: {\n"
" key: 1\n"
" sub: {}\n"
"}\n"
"# comment\n");
verifyFormat("sub: {\n"
" key: 1\n"
" # comment\n"
" sub: {}\n"
"}");
}
} // end namespace tooling } // end namespace tooling
} // end namespace clang } // end namespace clang