add inline comment for reserved and extensions

Change-Id: I2b7797d38e90862927d7482815e589da49e5a19b

cmd/protofmt/unformatted.proto

@@ -22,7 +22,7 @@ message Message
 
     string   name =1;
 // this is a thing
-    google.protobuf.Any anything = 2 [packed=true, danger=false];
+    google.protobuf.Any anything = 2 [packed=true, danger=false]; // anything
 
     repeated 
     Message 
@@ -39,14 +39,16 @@ message Message
     BILL_BAILEY = 3;
   }
 
-    reserved 2, 15, 9 to 11;
-    reserved "foo", "bar";
+    reserved 2, 15, 9 to 11; 
+    reserved "foo", "bar";  // foo bar
+
+    extensions 100 to 199; // no 200
 
   map<string, Nested> terrain = 4; // terrain
 
   enum EnumAllowingAlias {
-  option allow_alias = true;
-  UNKNOWN = 0;
+  option allow_alias = true; // allow_alias
+  UNKNOWN = 0; // UNKNOWN
   STARTED = 1;
   RUN = 2 [(custom_option) = "hello world"];
 }

extensions.go

@@ -3,7 +3,13 @@ package proto
 // Extensions declare that a range of field numbers in a message are available for third-party extensions.
 // proto2 only
 type Extensions struct {
-	Ranges string
+	Ranges  string
+	Comment *Comment
+}
+
+// inlineComment is part of commentInliner.
+func (e *Extensions) inlineComment(c *Comment) {
+	e.Comment = c
 }
 
 // Accept dispatches the call to the visitor.
@@ -15,5 +21,18 @@ func (e *Extensions) Accept(v Visitor) {
 func (e *Extensions) parse(p *Parser) error {
 	// TODO proper range parsing
 	e.Ranges = p.s.scanUntil(';')
+	p.s.unread(';') // for reading inline comment
 	return nil
 }
+
+// columns returns printable source tokens
+func (e *Extensions) columns() (cols []aligned) {
+	cols = append(cols,
+		notAligned("extensions "),
+		leftAligned(e.Ranges),
+		alignedSemicolon)
+	if e.Comment != nil {
+		cols = append(cols, notAligned(" //"), notAligned(e.Comment.Message))
+	}
+	return
+}

extensions_test.go

@@ -1 +1,29 @@
 package proto
+
+import "testing"
+
+func TestExtensions(t *testing.T) {
+	proto := `message M { 
+		extensions 4, 20 to max; // max
+	}`
+	p := newParserOn(proto)
+	p.scanIgnoreWhitespace() // consume extensions
+	m := new(Message)
+	err := m.parse(p)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(m.Elements) == 0 {
+		t.Fatal("extensions expected")
+	}
+	f := m.Elements[0].(*Extensions)
+	if got, want := f.Ranges, " 4, 20 to max"; got != want {
+		t.Errorf("got [%s] want [%s]", got, want)
+	}
+	if f.Comment == nil {
+		t.Fatal("comment expected")
+	}
+	if got, want := f.Comment.Message, " max"; got != want {
+		t.Errorf("got [%s] want [%s]", got, want)
+	}
+}

field.go

@@ -143,6 +143,34 @@ func (f *MapField) Accept(v Visitor) {
 	v.VisitMapField(f)
 }
 
+// columns returns printable source tokens
+func (f *MapField) columns() (cols []aligned) {
+	cols = append(cols,
+		notAligned("map <"),
+		rightAligned(f.KeyType),
+		notAligned(","),
+		leftAligned(f.Type),
+		notAligned("> "),
+		rightAligned(f.Name),
+		alignedEquals,
+		rightAligned(strconv.Itoa(f.Sequence)))
+	if len(f.Options) > 0 {
+		cols = append(cols, leftAligned(" ["))
+		for i, each := range f.Options {
+			if i > 0 {
+				cols = append(cols, alignedComma)
+			}
+			cols = append(cols, each.keyValuePair(true)...)
+		}
+		cols = append(cols, leftAligned("]"))
+	}
+	cols = append(cols, alignedSemicolon)
+	if f.Comment != nil {
+		cols = append(cols, notAligned(" //"), notAligned(f.Comment.Message))
+	}
+	return
+}
+
 // parse expects:
 // mapField = "map" "<" keyType "," type ">" mapName "=" fieldNumber [ "[" fieldOptions "]" ] ";"
 // keyType = "int32" | "int64" | "uint32" | "uint64" | "sint32" | "sint64" |

formatter.go

@@ -141,17 +141,14 @@ func (f *Formatter) VisitReserved(r *Reserved) {
 			fmt.Fprintf(f.w, "%q", each)
 		}
 	}
-	io.WriteString(f.w, ";\n")
+	f.endWithComment(r.Comment)
 }
 
 // VisitRPC formats a RPC.
 func (f *Formatter) VisitRPC(r *RPC) {}
 
 // VisitMapField formats a MapField.
-func (f *Formatter) VisitMapField(m *MapField) {
-	f.begin("map")
-	fmt.Fprintf(f.w, "map<%s,%s> %s = %d;\n", m.KeyType, m.Type, m.Name, m.Sequence)
-}
+func (f *Formatter) VisitMapField(m *MapField) {}
 
 // VisitNormalField formats a NormalField.
 func (f *Formatter) VisitNormalField(f1 *NormalField) {}
@@ -174,7 +171,4 @@ func (f *Formatter) VisitGroup(g *Group) {
 }
 
 // VisitExtensions formats a proto2 Extensions.
-func (f *Formatter) VisitExtensions(e *Extensions) {
-	f.indent(0)
-	fmt.Fprintf(f.w, "extensions %s;\n", e.Ranges)
-}
+func (f *Formatter) VisitExtensions(e *Extensions) {}

formatter_utils.go

@@ -113,3 +113,13 @@ func (f *Formatter) printAsGroups(list []Visitee) {
 	// print last group
 	f.printListOfColumns(group, lastGroupName)
 }
+
+// endWithComment writes a statement end (;) followed by inline comment if present.
+func (f *Formatter) endWithComment(commentOrNil *Comment) {
+	io.WriteString(f.w, ";")
+	if commentOrNil != nil {
+		io.WriteString(f.w, " //")
+		io.WriteString(f.w, commentOrNil.Message)
+	}
+	io.WriteString(f.w, "\n")
+}

proto.go

@@ -92,10 +92,12 @@ func (c Comment) IsMultiline() bool {
 	return strings.Contains(c.Message, "\n")
 }
 
+// commentInliner is for types that can have an inline comment.
 type commentInliner interface {
 	inlineComment(c *Comment)
 }
 
+// elementContainer unifies types that have elements.
 type elementContainer interface {
 	addElement(v Visitee)
 	elements() []Visitee

proto_test.go

@@ -27,14 +27,14 @@ func parseFormattedParsed(t *testing.T, filename string) {
 	// open it
 	f, err := os.Open(filename)
 	if err != nil {
-		t.Fatal(err)
+		t.Fatal(filename, err)
 	}
 	defer f.Close()
 	// parse it
 	p := NewParser(f)
 	def, err := p.Parse()
 	if err != nil {
-		t.Fatal(err)
+		t.Fatal(filename, err)
 	}
 	// count it
 	c := new(counter)
@@ -49,14 +49,14 @@ func parseFormattedParsed(t *testing.T, filename string) {
 	fp := NewParser(bytes.NewReader(out.Bytes()))
 	_, err = fp.Parse()
 	if err != nil {
-		t.Fatal(err)
+		t.Fatal(filename, err)
 	}
 	// count it again
 	c.count = 0
 	c.Count(def.Elements)
 	afterCount := c.count
 	if got, want := afterCount, beforeCount; got != want {
-		t.Errorf("got [%v] want [%v]", got, want)
+		t.Errorf("[%s] got [%v] want [%v]", filename, got, want)
 	}
 	t.Log("# proto elements", afterCount)
 }

reserved.go

@@ -10,6 +10,12 @@ import (
 type Reserved struct {
 	Ranges     string
 	FieldNames []string
+	Comment    *Comment
+}
+
+// inlineComment is part of commentInliner.
+func (r *Reserved) inlineComment(c *Comment) {
+	r.Comment = c
 }
 
 // Range is to specify number intervals
@@ -41,5 +47,6 @@ func (r *Reserved) parse(p *Parser) error {
 	} else {
 		r.Ranges = content
 	}
+	p.s.unread(';') // put it back for reading inline comments TODO
 	return nil
 }