txtpbfmt: Add support for formatting repeated primitive fields as lists.

When this option is used, repeated primitive fields are printed using a more conscice list syntax:

```textproto
repeated_field: 1
repeated_field: 2
repeated_field: 3
```

vs

```textproto
repeated_field: [1, 2, 3]
```

This syntax is part of the go/textformat-spec (screen/4cDavcUGvdjyWwN), thus it's supported by all parsers. Furthermore, some proto implementations (like [C++](http://google3/third_party/protobuf/text_format.h;l=407;rcl=828248838) and [Java](http://google3/third_party/java_src/protobuf/current/java/com/google/protobuf/TextFormat.java;l=385;rcl=815831657)) allow using it when printing text-proto.

This CL is a no-op if the config option isn't used.

PiperOrigin-RevId: 834277184

Author: Yassin Ezbakhe

config/config.go

@@ -87,6 +87,11 @@ type Config struct {
 	// Use single quotes around strings that contain double but not single quotes.
 	SmartQuotes bool
 
+	// Use a short representation for repeated primitive fields (`x: 1 x: 2` vs `x: [1, 2]`). If this
+	// field is true, all repeated primitive fields will use the short representation; otherwise, the
+	// latter will be used only if it's being used in the input textproto.
+	UseShortRepeatedPrimitiveFields bool
+
 	// Logger enables logging when it is non-nil.
 	// If the log messages aren't going to be useful, it's best to leave Logger
 	// set to nil, as otherwise log messages will be constructed.

impl/impl.go

@@ -254,6 +254,8 @@ func addToConfig(metaComment string, c *config.Config) error {
 		c.WrapStringsAfterNewlines = true
 	case "wrap_strings_without_wordwrap":
 		c.WrapStringsWithoutWordwrap = true
+	case "use_short_repeated_primitive_fields":
+		c.UseShortRepeatedPrimitiveFields = true
 	case "on": // This doesn't change the overall config.
 	case "off": // This doesn't change the overall config.
 	default:

parser/parser_test.go

@@ -1810,10 +1810,75 @@ a, b,
 `}, {
 		name: "carriage return \\r is formatted away",
 		in:   `foo: "bar"` + "\r" + `baz: "bat"` + "\r",
-		out:  `foo: "bar"` + "\n" + `baz: "bat"` + "\n"}, {
+		out:  `foo: "bar"` + "\n" + `baz: "bat"` + "\n",
+	}, {
 		name: "Windows-style newline \\r\\n is formatted away",
 		in:   `foo: "bar"` + "\r\n" + `baz: "bat"` + "\r\n",
-		out:  `foo: "bar"` + "\n" + `baz: "bat"` + "\n"}}
+		out:  `foo: "bar"` + "\n" + `baz: "bat"` + "\n",
+	}, {
+		name: "use short repeated primitive fields",
+		in: `# txtpbfmt: use_short_repeated_primitive_fields
+foo: 1
+foo: 2
+foo: 3
+`,
+		out: `# txtpbfmt: use_short_repeated_primitive_fields
+foo: [1, 2, 3]
+`}, {
+		name: "use short repeated primitive fields with single element list",
+		in: `# txtpbfmt: use_short_repeated_primitive_fields
+foo: 1
+`,
+		out: `# txtpbfmt: use_short_repeated_primitive_fields
+foo: 1
+`}, {
+		name: "use short repeated primitive fields with interleaved list",
+		in: `# txtpbfmt: use_short_repeated_primitive_fields
+foo: 1
+foo: 2
+bar: 3
+foo: 4
+foo: 5
+bar: 6
+bar: 7
+foo: 8
+`,
+		out: `# txtpbfmt: use_short_repeated_primitive_fields
+foo: [1, 2]
+bar: 3
+foo: [4, 5]
+bar: [6, 7]
+foo: 8
+`}, {
+		name: "use short repeated primitive fields with string field",
+		in: `# txtpbfmt: use_short_repeated_primitive_fields
+foo: "a"
+foo: "b"
+`,
+		out: `# txtpbfmt: use_short_repeated_primitive_fields
+foo: ["a", "b"]
+`}, {
+		name: "use short repeated primitive fields with message field",
+		in: `# txtpbfmt: use_short_repeated_primitive_fields
+foo { x: 1 }
+foo { x: 2 }
+`,
+		out: `# txtpbfmt: use_short_repeated_primitive_fields
+foo { x: 1 }
+foo { x: 2 }
+`}, {
+		name: "use short repeated primitive fields inside message",
+		in: `# txtpbfmt: use_short_repeated_primitive_fields
+foo { x: 1 x: 2 x: 3 }
+foo { x: 4 }
+foo { x: 5 x: 6 }
+`,
+		out: `# txtpbfmt: use_short_repeated_primitive_fields
+foo { x: [1, 2, 3] }
+foo { x: 4 }
+foo { x: [5, 6] }
+`},
+	}
 	for _, input := range inputs {
 		out, err := Format([]byte(input.in))
 		if err != nil {

printer/printer.go

@@ -32,7 +32,7 @@ func FormatWithConfig(in []byte, c config.Config) ([]byte, error) {
 	if err != nil {
 		return nil, err
 	}
-	return FormatNodes(nodes), nil
+	return FormatNodesWithDepthAndConfig(nodes, 0, c), nil
 }
 
 func removeDeleted(nodes []*ast.Node) []*ast.Node {
@@ -100,8 +100,13 @@ func FormatNodes(nodes []*ast.Node) []byte {
 
 // FormatNodesWithDepth returns formatted nodes at the given indentation depth (0 = top-level) as bytes.
 func FormatNodesWithDepth(nodes []*ast.Node, depth int) []byte {
+	return FormatNodesWithDepthAndConfig(nodes, depth, config.Config{})
+}
+
+// FormatNodesWithDepthAndConfig returns formatted nodes at the given indentation depth (0 = top-level) as bytes.
+func FormatNodesWithDepthAndConfig(nodes []*ast.Node, depth int, c config.Config) []byte {
 	var result bytes.Buffer
-	formatter{&result}.writeNodes(removeDeleted(nodes), depth, false /* isSameLine */, false /* asListItems */)
+	formatter{&result, c}.writeNodes(removeDeleted(nodes), depth, false /* isSameLine */, false /* asListItems */)
 	return result.Bytes()
 }
 
@@ -113,6 +118,7 @@ type stringWriter interface {
 // formatter accumulates pretty-printed textproto contents into a stringWriter.
 type formatter struct {
 	stringWriter
+	config.Config
 }
 
 func (f formatter) writeNode(nd *ast.Node, depth int, isSameLine, asListItems bool, index, lastNonCommentIndex int) {
@@ -204,7 +210,8 @@ func (f formatter) writeNodeName(nd *ast.Node, indent string) {
 }
 
 func (f formatter) writeNodeValues(nd *ast.Node, indent string) {
-	if nd.ValuesAsList { // For ValuesAsList option we will preserve even empty list  `field: []`
+	if nd.ValuesAsList {
+		// For ValuesAsList option we will preserve even empty list  `field: []`
 		f.writeValuesAsList(nd, nd.Values, indent+indentSpaces)
 	} else if len(nd.Values) > 0 {
 		f.writeValues(nd, nd.Values, indent+indentSpaces)

sort/sort.go

@@ -56,19 +56,19 @@ type valuesSortFunction func(values []*ast.Value)
 
 // Process sorts and filters the given nodes.
 func Process(parent *ast.Node, nodes []*ast.Node, c config.Config) error {
-	return process(parent, nodes, nodeSortFunctionConfig(c), nodeFilterFunctionConfig(c), valuesSortFunctionConfig(c))
+	return process(parent, nodes, nodeSortFunctionConfig(c), nodeFilterFunctionConfig(c), valuesSortFunctionConfig(c), c)
 }
 
 // process sorts and filters the given nodes.
-func process(parent *ast.Node, nodes []*ast.Node, sortFunction nodeSortFunction, filterFunction nodeFilterFunction, valuesSortFunction valuesSortFunction) error {
+func process(parent *ast.Node, nodes []*ast.Node, sortFunction nodeSortFunction, filterFunction nodeFilterFunction, valuesSortFunction valuesSortFunction, c config.Config) error {
 	if len(nodes) == 0 {
 		return nil
 	}
 	if filterFunction != nil {
 		filterFunction(nodes)
 	}
 	for _, nd := range nodes {
-		err := process(nd, nd.Children, sortFunction, filterFunction, valuesSortFunction)
+		err := process(nd, nd.Children, sortFunction, filterFunction, valuesSortFunction, c)
 		if err != nil {
 			return err
 		}
@@ -77,11 +77,46 @@ func process(parent *ast.Node, nodes []*ast.Node, sortFunction nodeSortFunction,
 		}
 	}
 	if sortFunction != nil {
-		return sortFunction(parent, nodes)
+		if err := sortFunction(parent, nodes); err != nil {
+			return err
+		}
+	}
+	if c.UseShortRepeatedPrimitiveFields {
+		groupRepeatedPrimitiveFields(nodes)
 	}
 	return nil
 }
 
+func isPrimitive(n *ast.Node) bool {
+	return len(n.Children) == 0 && len(n.Values) == 1
+}
+
+func groupRepeatedPrimitiveFields(nodes []*ast.Node) {
+	for i := 0; i < len(nodes); {
+		node := nodes[i]
+		if node.Deleted || !isPrimitive(node) {
+			i++
+			continue
+		}
+		j := i + 1
+		for ; j < len(nodes); j++ {
+			if nodes[j].Deleted || !isPrimitive(nodes[j]) || nodes[j].Name != node.Name || len(nodes[j].PreComments) > 0 {
+				break
+			}
+		}
+		if j > i+1 {
+			// Found group of repeated primitive fields: nodes[i...j-1]
+			node.ValuesAsList = true
+			node.ChildrenSameLine = true
+			for k := i + 1; k < j; k++ {
+				node.Values = append(node.Values, nodes[k].Values...)
+				nodes[k].Deleted = true
+			}
+		}
+		i = j
+	}
+}
+
 // removeDuplicates marks duplicate key:value pairs from nodes as Deleted.
 func removeDuplicates(nodes []*ast.Node) {
 	type nameAndValue struct {

sort/sort_test.go

@@ -150,6 +150,43 @@ func TestProcess(t *testing.T) {
 				ValuesAsList: true,
 			},
 		},
+	}, {
+		name: "use short repeated primitive fields",
+		nodes: []*ast.Node{
+			{Name: "foo", Values: []*ast.Value{{Value: "1"}}},
+			{Name: "foo", Values: []*ast.Value{{Value: "2"}}},
+			{Name: "bar", Values: []*ast.Value{{Value: "3"}}},
+		},
+		c: config.Config{
+			UseShortRepeatedPrimitiveFields: true,
+		},
+		want: []*ast.Node{
+			{Name: "foo", Values: []*ast.Value{{Value: "1"}, {Value: "2"}}, ValuesAsList: true, ChildrenSameLine: true},
+			{Name: "foo", Values: []*ast.Value{{Value: "2"}}, Deleted: true},
+			{Name: "bar", Values: []*ast.Value{{Value: "3"}}},
+		},
+	}, {
+		name: "use short repeated primitive fields with single element list (ValuesAsList: true)",
+		nodes: []*ast.Node{
+			{Name: "foo", Values: []*ast.Value{{Value: "1"}}, ValuesAsList: true},
+		},
+		c: config.Config{
+			UseShortRepeatedPrimitiveFields: true,
+		},
+		want: []*ast.Node{
+			{Name: "foo", Values: []*ast.Value{{Value: "1"}}, ValuesAsList: true},
+		},
+	}, {
+		name: "use short repeated primitive fields with single element list (ValuesAsList: false)",
+		nodes: []*ast.Node{
+			{Name: "foo", Values: []*ast.Value{{Value: "1"}}},
+		},
+		c: config.Config{
+			UseShortRepeatedPrimitiveFields: true,
+		},
+		want: []*ast.Node{
+			{Name: "foo", Values: []*ast.Value{{Value: "1"}}},
+		},
 	}, {
 		name: "error in sort function",
 		nodes: []*ast.Node{
@@ -184,7 +221,7 @@ func TestProcess(t *testing.T) {
 			if tc.skipValuesFunction {
 				valuesFunction = nil
 			}
-			err := process(nil, tc.nodes, sortFunction, filterFunction, valuesFunction)
+			err := process(nil, tc.nodes, sortFunction, filterFunction, valuesFunction, tc.c)
 			if tc.wantErr != "" {
 				if err == nil {
 					t.Errorf("process(%v, %v, %v, %v) got nil error, want %q", tc.nodes, sortFunction, filterFunction, valuesFunction, tc.wantErr)