Implement oneof support.

This includes the code generation changes,
and the infrastructure to wire it up to the encode/decode machinery.

The overall API changes are these:
  - oneofs in a message are replaced by a single interface field
  - each field in a oneof gets a distinguished type that satisfies
    the corresponding interface
  - a type switch may be used to distinguish between oneof fields

Fixes #29.

Makefile

@@ -51,5 +51,6 @@ nuke:
 regenerate:
 	make -C protoc-gen-go/descriptor regenerate
 	make -C protoc-gen-go/plugin regenerate
+	make -C protoc-gen-go/testdata regenerate
 	make -C proto/testdata regenerate
 	make -C jsonpb/jsonpb_test_proto regenerate

jsonpb/jsonpb.go

@@ -111,6 +111,18 @@ func (m *Marshaler) marshalObject(out *errWriter, v proto.Message, indent string
 			}
 		}
 
+		// Oneof fields need special handling.
+		if valueField.Tag.Get("protobuf_oneof") != "" {
+			// value is an interface containing &T{real_value}.
+			sv := value.Elem().Elem() // interface -> *T -> T
+			value = sv.Field(0)
+			valueField = sv.Type().Field(0)
+
+			var p proto.Properties
+			p.Parse(sv.Type().Field(0).Tag.Get("protobuf"))
+			fieldName = p.OrigName
+		}
+
 		out.write(writeBeforeField)
 		if m.Indent != "" {
 			out.write(indent)
@@ -319,6 +331,44 @@ func unmarshalValue(target reflect.Value, inputValue json.RawMessage) error {
 				delete(jsonFields, fieldName)
 			}
 		}
+		// Check for any oneof fields.
+		// This might be slow; we can optimise it if it becomes a problem.
+		type oneofMessage interface {
+			XXX_OneofFuncs() (func(proto.Message, *proto.Buffer) error, func(proto.Message, int, int, *proto.Buffer) (bool, error), []interface{})
+		}
+		var oneofTypes []interface{}
+		if om, ok := reflect.Zero(reflect.PtrTo(targetType)).Interface().(oneofMessage); ok {
+			_, _, oneofTypes = om.XXX_OneofFuncs()
+		}
+		for fname, raw := range jsonFields {
+			for _, oot := range oneofTypes {
+				sp := reflect.ValueOf(oot).Type() // *T
+				var props proto.Properties
+				props.Parse(sp.Elem().Field(0).Tag.Get("protobuf"))
+				if props.OrigName != fname {
+					continue
+				}
+				nv := reflect.New(sp.Elem())
+				// There will be exactly one interface field that
+				// this new value is assignable to.
+				for i := 0; i < targetType.NumField(); i++ {
+					f := targetType.Field(i)
+					if f.Type.Kind() != reflect.Interface {
+						continue
+					}
+					if !nv.Type().AssignableTo(f.Type) {
+						continue
+					}
+					target.Field(i).Set(nv)
+					break
+				}
+				if err := unmarshalValue(nv.Elem().Field(0), raw); err != nil {
+					return err
+				}
+				delete(jsonFields, fname)
+				break
+			}
+		}
 		if len(jsonFields) > 0 {
 			// Pick any field to be the scapegoat.
 			var f string

jsonpb/jsonpb_test.go

@@ -32,6 +32,7 @@
 package jsonpb
 
 import (
+	"reflect"
 	"testing"
 
 	pb "github.com/golang/protobuf/jsonpb/jsonpb_test_proto"
@@ -291,6 +292,8 @@ var marshalingTests = []struct {
 	{"proto2 map<bool, Object>", marshaler,
 		&pb.Maps{MBoolSimple: map[bool]*pb.Simple{true: &pb.Simple{OInt32: proto.Int32(1)}}},
 		`{"m_bool_simple":{"true":{"o_int32":1}}}`},
+	{"oneof, not set", marshaler, &pb.MsgWithOneof{}, `{}`},
+	{"oneof, set", marshaler, &pb.MsgWithOneof{Union: &pb.MsgWithOneof_Title{"Grand Poobah"}}, `{"title":"Grand Poobah"}`},
 }
 
 func TestMarshaling(t *testing.T) {
@@ -325,13 +328,13 @@ var unmarshalingTests = []struct {
 	{"map<int64, int32>", `{"nummy":{"1":2,"3":4}}`, &pb.Mappy{Nummy: map[int64]int32{1: 2, 3: 4}}},
 	{"map<string, string>", `{"strry":{"\"one\"":"two","three":"four"}}`, &pb.Mappy{Strry: map[string]string{`"one"`: "two", "three": "four"}}},
 	{"map<int32, Object>", `{"objjy":{"1":{"dub":1}}}`, &pb.Mappy{Objjy: map[int32]*pb.Simple3{1: &pb.Simple3{Dub: 1}}}},
+	{"oneof", `{"salary":31000}`, &pb.MsgWithOneof{Union: &pb.MsgWithOneof_Salary{31000}}},
 }
 
 func TestUnmarshaling(t *testing.T) {
 	for _, tt := range unmarshalingTests {
 		// Make a new instance of the type of our expected object.
-		p := proto.Clone(tt.pb)
-		p.Reset()
+		p := reflect.New(reflect.TypeOf(tt.pb).Elem()).Interface().(proto.Message)
 
 		err := UnmarshalString(tt.json, p)
 		if err != nil {

jsonpb/jsonpb_test_proto/test_objects.proto

@@ -84,3 +84,10 @@ message Maps {
   map<int64, string> m_int64_str = 1;
   map<bool, Simple> m_bool_simple = 2;
 }
+
+message MsgWithOneof {
+  oneof union {
+    string title = 1;
+    int64 salary = 2;
+  }
+}

proto/all_test.go

@@ -1958,6 +1958,58 @@ func TestMapFieldWithNil(t *testing.T) {
 	}
 }
 
+func TestOneof(t *testing.T) {
+	m := &Communique{}
+	b, err := Marshal(m)
+	if err != nil {
+		t.Fatalf("Marshal of empty message with oneof: %v", err)
+	}
+	if len(b) != 0 {
+		t.Errorf("Marshal of empty message yielded too many bytes: %v", b)
+	}
+
+	m = &Communique{
+		Union: &Communique_Name{"Barry"},
+	}
+
+	// Round-trip.
+	b, err = Marshal(m)
+	if err != nil {
+		t.Fatalf("Marshal of message with oneof: %v", err)
+	}
+	if len(b) != 7 { // name tag/wire (1) + name len (1) + name (5)
+		t.Errorf("Incorrect marshal of message with oneof: %v", b)
+	}
+	m.Reset()
+	if err := Unmarshal(b, m); err != nil {
+		t.Fatalf("Unmarshal of message with oneof: %v", err)
+	}
+	if x, ok := m.Union.(*Communique_Name); !ok || x.Name != "Barry" {
+		t.Errorf("After round trip, Union = %+v", m.Union)
+	}
+	if name := m.GetName(); name != "Barry" {
+		t.Errorf("After round trip, GetName = %q, want %q", name, "Barry")
+	}
+
+	// Let's try with a message in the oneof.
+	m.Union = &Communique_Msg{&Strings{StringField: String("deep deep string")}}
+	b, err = Marshal(m)
+	if err != nil {
+		t.Fatalf("Marshal of message with oneof set to message: %v", err)
+	}
+	if len(b) != 20 { // msg tag/wire (1) + msg len (1) + msg (1 + 1 + 16)
+		t.Errorf("Incorrect marshal of message with oneof set to message: %v", b)
+	}
+	m.Reset()
+	if err := Unmarshal(b, m); err != nil {
+		t.Fatalf("Unmarshal of message with oneof set to message: %v", err)
+	}
+	ss, ok := m.Union.(*Communique_Msg)
+	if !ok || ss.Msg.GetStringField() != "deep deep string" {
+		t.Errorf("After round trip with oneof set to message, Union = %+v", m.Union)
+	}
+}
+
 // Benchmarks
 
 func testMsg() *GoTest {

proto/clone.go

@@ -120,6 +120,13 @@ func mergeAny(out, in reflect.Value, viaPtr bool, prop *Properties) {
 			return
 		}
 		out.Set(in)
+	case reflect.Interface:
+		// Probably a oneof field; copy non-nil values.
+		if in.IsNil() {
+			return
+		}
+		out.Set(reflect.New(in.Elem().Elem().Type())) // interface -> *T -> T -> new(T)
+		mergeAny(out.Elem(), in.Elem(), false, nil)
 	case reflect.Map:
 		if in.Len() == 0 {
 			return

proto/clone_test.go

@@ -232,6 +232,28 @@ var mergeTests = []struct {
 			Data:       []byte("texas!"),
 		},
 	},
+	// Oneof fields should merge by assignment.
+	{
+		src: &pb.Communique{
+			Union: &pb.Communique_Number{41},
+		},
+		dst: &pb.Communique{
+			Union: &pb.Communique_Name{"Bobby Tables"},
+		},
+		want: &pb.Communique{
+			Union: &pb.Communique_Number{41},
+		},
+	},
+	// Oneof nil is the same as not set.
+	{
+		src: &pb.Communique{},
+		dst: &pb.Communique{
+			Union: &pb.Communique_Name{"Bobby Tables"},
+		},
+		want: &pb.Communique{
+			Union: &pb.Communique_Name{"Bobby Tables"},
+		},
+	},
 }
 
 func TestMerge(t *testing.T) {