goprotobuf: Support extensions in text parser.

R=r
TBR=r
CC=golang-dev
http://codereview.appspot.com/5462043

proto/testdata/test.proto

@@ -241,6 +241,8 @@ message MyMessage {
 message Ext {
   extend MyMessage {
     optional Ext more = 103;
+    optional string text = 104;
+    optional int32 number = 105;
   }
 
   optional string data = 1;

proto/text_parser.go

@@ -32,7 +32,7 @@
 package proto
 
 // Functions for parsing the Text protocol buffer format.
-// TODO: message sets, extensions.
+// TODO: message sets.
 
 import (
 	"fmt"
@@ -151,7 +151,7 @@ func (p *textParser) advance() {
 	p.cur.offset, p.cur.line = p.offset, p.line
 	p.cur.unquoted = ""
 	switch p.s[0] {
-	case '<', '>', '{', '}', ':':
+	case '<', '>', '{', '}', ':', '[', ']':
 		// Single symbol
 		p.cur.value, p.s = p.s[0:1], p.s[1:len(p.s)]
 	case '"':
@@ -252,11 +252,50 @@ func structFieldByName(st reflect.Type, name string) (int, *Properties, bool) {
 	return -1, nil, false
 }
 
+// Consume a ':' from the input stream (if the next token is a colon),
+// returning an error if a colon is needed but not present.
+func (p *textParser) checkForColon(props *Properties, typ reflect.Type) *ParseError {
+	tok := p.next()
+	if tok.err != nil {
+		return tok.err
+	}
+	if tok.value != ":" {
+		// Colon is optional when the field is a group or message.
+		needColon := true
+		switch props.Wire {
+		case "group":
+			needColon = false
+		case "bytes":
+			// A "bytes" field is either a message, a string, or a repeated field;
+			// those three become *T, *string and []T respectively, so we can check for
+			// this field being a pointer to a non-string.
+			if typ.Kind() == reflect.Ptr {
+				// *T or *string
+				if typ.Elem().Kind() == reflect.String {
+					break
+				}
+			} else if typ.Kind() == reflect.Slice {
+				// []T or []*T
+				if typ.Elem().Kind() != reflect.Ptr {
+					break
+				}
+			}
+			needColon = false
+		}
+		if needColon {
+			return p.errorf("expected ':', found %q", tok.value)
+		}
+		p.back()
+	}
+	return nil
+}
+
 func (p *textParser) readStruct(sv reflect.Value, terminator string) *ParseError {
 	st := sv.Type()
 	reqCount := GetProperties(st).reqCount
 	// A struct is a sequence of "name: value", terminated by one of
-	// '>' or '}', or the end of the input.
+	// '>' or '}', or the end of the input.  A name may also be
+	// "[extension]".
 	for {
 		tok := p.next()
 		if tok.err != nil {
@@ -265,58 +304,76 @@ func (p *textParser) readStruct(sv reflect.Value, terminator string) *ParseError
 		if tok.value == terminator {
 			break
 		}
+		if tok.value == "[" {
+			// Looks like an extension.
+			//
+			// TODO: Check whether we need to handle
+			// namespace rooted names (e.g. ".something.Foo").
+			tok = p.next()
+			if tok.err != nil {
+				return tok.err
+			}
+			var desc *ExtensionDesc
+			// This could be faster, but it's functional.
+			// TODO: Do something smarter than a linear scan.
+			for _, d := range RegisteredExtensions(reflect.New(st).Interface()) {
+				if d.Name == tok.value {
+					desc = d
+					break
+				}
+			}
+			if desc == nil {
+				return p.errorf("unrecognized extension %q", tok.value)
+			}
+			// Check the extension terminator.
+			tok = p.next()
+			if tok.err != nil {
+				return tok.err
+			}
+			if tok.value != "]" {
+				return p.errorf("unrecognized extension terminator %q", tok.value)
+			}
 
-		fi, props, ok := structFieldByName(st, tok.value)
-		if !ok {
-			return p.errorf("unknown field name %q in %v", tok.value, st)
-		}
+			props := &Properties{}
+			props.Parse(desc.Tag)
 
-		// Check that it's not already set if it's not a repeated field.
-		if !props.Repeated && !isNil(sv.Field(fi)) {
-			return p.errorf("non-repeated field %q was repeated", tok.value)
-		}
+			typ := reflect.TypeOf(desc.ExtensionType)
+			if err := p.checkForColon(props, typ); err != nil {
+				return err
+			}
 
-		tok = p.next()
-		if tok.err != nil {
-			return tok.err
-		}
-		if tok.value != ":" {
-			// Colon is optional when the field is a group or message.
-			needColon := true
-			switch props.Wire {
-			case "group":
-				needColon = false
-			case "bytes":
-				// A "bytes" field is either a message, a string, or a repeated field;
-				// those three become *T, *string and []T respectively, so we can check for
-				// this field being a pointer to a non-string.
-				typ := st.Field(fi).Type
-				if typ.Kind() == reflect.Ptr {
-					// *T or *string
-					if typ.Elem().Kind() == reflect.String {
-						break
-					}
-				} else if typ.Kind() == reflect.Slice {
-					// []T or []*T
-					if typ.Elem().Kind() != reflect.Ptr {
-						break
-					}
-				}
-				needColon = false
+			// Read the extension structure, and set it in
+			// the value we're constructing.
+			ext := reflect.New(typ).Elem()
+			if err := p.readAny(ext, props); err != nil {
+				return err
 			}
-			if needColon {
-				return p.errorf("expected ':', found %q", tok.value)
+			SetExtension(sv.Addr().Interface().(extendableProto),
+				desc, ext.Interface())
+		} else {
+			// This is a normal, non-extension field.
+			fi, props, ok := structFieldByName(st, tok.value)
+			if !ok {
+				return p.errorf("unknown field name %q in %v", tok.value, st)
 			}
-			p.back()
-		}
 
-		// Parse into the field.
-		if err := p.readAny(sv.Field(fi), props); err != nil {
-			return err
-		}
+			// Check that it's not already set if it's not a repeated field.
+			if !props.Repeated && !isNil(sv.Field(fi)) {
+				return p.errorf("non-repeated field %q was repeated", tok.value)
+			}
 
-		if props.Required {
-			reqCount--
+			if err := p.checkForColon(props, st.Field(fi).Type); err != nil {
+				return err
+			}
+
+			// Parse into the field.
+			if err := p.readAny(sv.Field(fi), props); err != nil {
+				return err
+			}
+
+			if props.Required {
+				reqCount--
+			}
 		}
 	}
 

proto/text_parser_test.go

@@ -44,6 +44,25 @@ type UnmarshalTextTest struct {
 	out *MyMessage
 }
 
+func buildExtStructTest(text string) UnmarshalTextTest {
+	msg := &MyMessage{
+		Count: Int32(42),
+	}
+	SetExtension(msg, E_Ext_More, &Ext{
+		Data: String("Hello, world!"),
+	})
+	return UnmarshalTextTest{in: text, out: msg}
+}
+
+func buildExtDataTest(text string) UnmarshalTextTest {
+	msg := &MyMessage{
+		Count: Int32(42),
+	}
+	SetExtension(msg, E_Ext_Text, String("Hello, world!"))
+	SetExtension(msg, E_Ext_Number, Int32(1729))
+	return UnmarshalTextTest{in: text, out: msg}
+}
+
 var unMarshalTextTests = []UnmarshalTextTest{
 	// Basic
 	{
@@ -192,6 +211,11 @@ var unMarshalTextTests = []UnmarshalTextTest{
 		},
 	},
 
+	// Extension
+	buildExtStructTest(`count: 42 [test_proto.Ext.more]:<data:"Hello, world!" >`),
+	buildExtStructTest(`count: 42 [test_proto.Ext.more] {data:"Hello, world!"}`),
+	buildExtDataTest(`count: 42 [test_proto.Ext.text]:"Hello, world!" [test_proto.Ext.number]:1729`),
+
 	// Big all-in-one
 	{
 		in: "count:42  # Meaning\n" +

proto/text_test.go

@@ -85,12 +85,12 @@ func newTestMessage() *pb.MyMessage {
 	if err != nil {
 		panic(err)
 	}
-	b = append(proto.EncodeVarint(104<<3|proto.WireBytes), b...)
-	proto.SetRawExtension(msg, 104, b)
+	b = append(proto.EncodeVarint(201<<3|proto.WireBytes), b...)
+	proto.SetRawExtension(msg, 201, b)
 
 	// Extensions can be plain fields, too, so let's test that.
-	b = append(proto.EncodeVarint(105<<3|proto.WireVarint), 19)
-	proto.SetRawExtension(msg, 105, b)
+	b = append(proto.EncodeVarint(202<<3|proto.WireVarint), 19)
+	proto.SetRawExtension(msg, 202, b)
 
 	return msg
 }
@@ -127,9 +127,9 @@ tag13: 4
   data: "Big gobs for big rats"
 >
 /* 13 unknown bytes */
-tag104: "\t3G skiing"
+tag201: "\t3G skiing"
 /* 3 unknown bytes */
-tag105: 19
+tag202: 19
 `
 
 func TestMarshalTextFull(t *testing.T) {