internal/impl: support message and enum fields

Dynamically generate functions for handling message and enum fields,
regardless of whether they are of the v1 or v2 forms.

If a v1 message is encountered, it is automatically wrapped such that it
implements the v2 interface.

Change-Id: I457bc5286892e8fc00a61da7062dd33058daafd5
Reviewed-on: https://go-review.googlesource.com/c/143837
Reviewed-by: Damien Neil <dneil@google.com>

internal/impl/legacy_message.go

@@ -18,10 +18,26 @@ import (
 	ptype "github.com/golang/protobuf/v2/reflect/prototype"
 )
 
+var messageTypeCache sync.Map // map[reflect.Type]*MessageType
+
+// wrapLegacyMessage wraps v as a protoreflect.Message, where v must be
+// a *struct kind and not implement the v2 API already.
+func wrapLegacyMessage(v reflect.Value) pref.Message {
+	// Fast-path: check if a MessageType is cached for this concrete type.
+	if mt, ok := messageTypeCache.Load(v.Type()); ok {
+		return mt.(*MessageType).MessageOf(v.Interface())
+	}
+
+	// Slow-path: derive message descriptor and initialize MessageType.
+	mt := &MessageType{Desc: loadMessageDesc(v.Type())}
+	messageTypeCache.Store(v.Type(), mt)
+	return mt.MessageOf(v.Interface())
+}
+
 var messageDescCache sync.Map // map[reflect.Type]protoreflect.MessageDescriptor
 
 // loadMessageDesc returns an MessageDescriptor derived from the Go type,
-// which must be an *struct kind and not implement the v2 API already.
+// which must be a *struct kind and not implement the v2 API already.
 func loadMessageDesc(t reflect.Type) pref.MessageDescriptor {
 	return messageDescSet{}.Load(t)
 }

internal/impl/message_field.go

@@ -60,8 +60,7 @@ func fieldInfoForOneof(fd pref.FieldDescriptor, fs reflect.StructField, ot refle
 			rv := p.apply(fieldOffset).asType(fs.Type).Elem()
 			if rv.IsNil() || rv.Elem().Type().Elem() != ot {
 				if fd.Kind() == pref.MessageKind || fd.Kind() == pref.GroupKind {
-					// Return a typed nil pointer of the message type to be
-					// consistent with the behavior of generated getters.
+					// TODO: Should this return an invalid protoreflect.Value?
 					rv = reflect.Zero(ot.Field(0).Type)
 					return conv.toPB(rv)
 				}
@@ -198,6 +197,8 @@ func (ms mapReflect) Unwrap() interface{} { // TODO: unexport?
 }
 func (ms mapReflect) ProtoMutable() {}
 
+var _ pref.Map = mapReflect{}
+
 func fieldInfoForVector(fd pref.FieldDescriptor, fs reflect.StructField) fieldInfo {
 	ft := fs.Type
 	if ft.Kind() != reflect.Slice {
@@ -349,8 +350,44 @@ func fieldInfoForScalar(fd pref.FieldDescriptor, fs reflect.StructField) fieldIn
 }
 
 func fieldInfoForMessage(fd pref.FieldDescriptor, fs reflect.StructField) fieldInfo {
-	// TODO: support vector fields.
-	panic(fmt.Sprintf("invalid field: %v", fd))
+	ft := fs.Type
+	conv := matchGoTypePBKind(ft, fd.Kind())
+	fieldOffset := offsetOf(fs)
+	// TODO: Implement unsafe fast path?
+	return fieldInfo{
+		has: func(p pointer) bool {
+			rv := p.apply(fieldOffset).asType(fs.Type).Elem()
+			return !rv.IsNil()
+		},
+		get: func(p pointer) pref.Value {
+			// TODO: If rv.IsNil(), should this return a typed-nil pointer or
+			// an invalid protoreflect.Value?
+			//
+			// Returning a typed nil pointer assumes that such values
+			// are valid for all possible custom message types,
+			// which may not be case for dynamic messages.
+			rv := p.apply(fieldOffset).asType(fs.Type).Elem()
+			return conv.toPB(rv)
+		},
+		set: func(p pointer, v pref.Value) {
+			// TODO: Similarly, is it valid to set this to a typed nil pointer?
+			rv := p.apply(fieldOffset).asType(fs.Type).Elem()
+			rv.Set(conv.toGo(v))
+		},
+		clear: func(p pointer) {
+			rv := p.apply(fieldOffset).asType(fs.Type).Elem()
+			rv.Set(reflect.Zero(rv.Type()))
+		},
+		mutable: func(p pointer) pref.Mutable {
+			// Mutable is only valid for messages and panics for other kinds.
+			rv := p.apply(fieldOffset).asType(fs.Type).Elem()
+			if rv.IsNil() {
+				pv := pref.ValueOf(conv.newMessage())
+				rv.Set(conv.toGo(pv))
+			}
+			return conv.toPB(rv).Message()
+		},
+	}
 }
 
 // messageV1 is the protoV1.Message interface.
@@ -424,22 +461,84 @@ func matchGoTypePBKind(t reflect.Type, k pref.Kind) converter {
 	case pref.EnumKind:
 		// Handle v2 enums, which must satisfy the proto.Enum interface.
 		if t.Kind() != reflect.Ptr && t.Implements(enumIfaceV2) {
-			// TODO: implement this.
+			et := reflect.Zero(t).Interface().(pref.ProtoEnum).ProtoReflect().Type()
+			return converter{
+				toPB: func(v reflect.Value) pref.Value {
+					if v.Type() != t {
+						panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), t))
+					}
+					e := v.Interface().(pref.ProtoEnum)
+					return pref.ValueOf(e.ProtoReflect().Number())
+				},
+				toGo: func(v pref.Value) reflect.Value {
+					rv := reflect.ValueOf(et.GoNew(v.Enum()))
+					if rv.Type() != t {
+						panic(fmt.Sprintf("invalid type: got %v, want %v", rv.Type(), t))
+					}
+					return rv
+				},
+			}
 		}
 
 		// Handle v1 enums, which we identify as simply a named int32 type.
 		if t.Kind() == reflect.Int32 && t.PkgPath() != "" {
-			// TODO: need logic to wrap a legacy enum to implement this.
+			return converter{
+				toPB: func(v reflect.Value) pref.Value {
+					if v.Type() != t {
+						panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), t))
+					}
+					return pref.ValueOf(pref.EnumNumber(v.Int()))
+				},
+				toGo: func(v pref.Value) reflect.Value {
+					return reflect.ValueOf(v.Enum()).Convert(t)
+				},
+			}
 		}
 	case pref.MessageKind, pref.GroupKind:
 		// Handle v2 messages, which must satisfy the proto.Message interface.
 		if t.Kind() == reflect.Ptr && t.Implements(messageIfaceV2) {
-			// TODO: implement this.
+			mt := reflect.Zero(t).Interface().(pref.ProtoMessage).ProtoReflect().Type()
+			return converter{
+				toPB: func(v reflect.Value) pref.Value {
+					if v.Type() != t {
+						panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), t))
+					}
+					return pref.ValueOf(v.Interface())
+				},
+				toGo: func(v pref.Value) reflect.Value {
+					rv := reflect.ValueOf(v.Message())
+					if rv.Type() != t {
+						panic(fmt.Sprintf("invalid type: got %v, want %v", rv.Type(), t))
+					}
+					return rv
+				},
+				newMessage: func() pref.Message {
+					return mt.GoNew().ProtoReflect()
+				},
+			}
 		}
 
 		// Handle v1 messages, which we need to wrap as a v2 message.
 		if t.Kind() == reflect.Ptr && t.Implements(messageIfaceV1) {
-			// TODO: need logic to wrap a legacy message.
+			return converter{
+				toPB: func(v reflect.Value) pref.Value {
+					if v.Type() != t {
+						panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), t))
+					}
+					return pref.ValueOf(wrapLegacyMessage(v))
+				},
+				toGo: func(v pref.Value) reflect.Value {
+					type unwrapper interface{ Unwrap() interface{} }
+					rv := reflect.ValueOf(v.Message().(unwrapper).Unwrap())
+					if rv.Type() != t {
+						panic(fmt.Sprintf("invalid type: got %v, want %v", rv.Type(), t))
+					}
+					return rv
+				},
+				newMessage: func() pref.Message {
+					return wrapLegacyMessage(reflect.New(t.Elem()))
+				},
+			}
 		}
 	}
 	panic(fmt.Sprintf("invalid Go type %v for protobuf kind %v", t, k))

internal/impl/message_test.go

@@ -41,13 +41,34 @@ type (
 	MyString  string
 	MyBytes   []byte
 
-	NamedStrings []MyString
-	NamedBytes   []MyBytes
+	VectorStrings []MyString
+	VectorBytes   []MyBytes
 
 	MapStrings map[MyString]MyString
 	MapBytes   map[MyString]MyBytes
+
+	MyEnumV1 pref.EnumNumber
+	MyEnumV2 string
+	myEnumV2 MyEnumV2
+
+	MyMessageV1 struct {
+		// SubMessage *Message
+	}
+	MyMessageV2 map[pref.FieldNumber]pref.Value
+	myMessageV2 MyMessageV2
 )
 
+func (e MyEnumV2) ProtoReflect() pref.Enum { return myEnumV2(e) }
+func (e myEnumV2) Type() pref.EnumType     { return nil } // TODO
+func (e myEnumV2) Number() pref.EnumNumber { return 0 }   // TODO
+
+func (m *MyMessageV2) ProtoReflect() pref.Message        { return (*myMessageV2)(m) }
+func (m *myMessageV2) Type() pref.MessageType            { return nil } // TODO
+func (m *myMessageV2) KnownFields() pref.KnownFields     { return nil } // TODO
+func (m *myMessageV2) UnknownFields() pref.UnknownFields { return nil } // TODO
+func (m *myMessageV2) Interface() pref.ProtoMessage      { return (*MyMessageV2)(m) }
+func (m *myMessageV2) ProtoMutable()                     {}
+
 // List of test operations to perform on messages, vectors, or maps.
 type (
 	messageOp  interface{} // equalMessage | hasFields | getFields | setFields | clearFields | vectorFields | mapFields
@@ -96,33 +117,33 @@ type (
 	// TODO: Mutable
 )
 
-func TestScalarProto2(t *testing.T) {
-	type ScalarProto2 struct {
-		Bool    *bool    `protobuf:"1"`
-		Int32   *int32   `protobuf:"2"`
-		Int64   *int64   `protobuf:"3"`
-		Uint32  *uint32  `protobuf:"4"`
-		Uint64  *uint64  `protobuf:"5"`
-		Float32 *float32 `protobuf:"6"`
-		Float64 *float64 `protobuf:"7"`
-		String  *string  `protobuf:"8"`
-		StringA []byte   `protobuf:"9"`
-		Bytes   []byte   `protobuf:"10"`
-		BytesA  *string  `protobuf:"11"`
-
-		MyBool    *MyBool    `protobuf:"12"`
-		MyInt32   *MyInt32   `protobuf:"13"`
-		MyInt64   *MyInt64   `protobuf:"14"`
-		MyUint32  *MyUint32  `protobuf:"15"`
-		MyUint64  *MyUint64  `protobuf:"16"`
-		MyFloat32 *MyFloat32 `protobuf:"17"`
-		MyFloat64 *MyFloat64 `protobuf:"18"`
-		MyString  *MyString  `protobuf:"19"`
-		MyStringA MyBytes    `protobuf:"20"`
-		MyBytes   MyBytes    `protobuf:"21"`
-		MyBytesA  *MyString  `protobuf:"22"`
-	}
+type ScalarProto2 struct {
+	Bool    *bool    `protobuf:"1"`
+	Int32   *int32   `protobuf:"2"`
+	Int64   *int64   `protobuf:"3"`
+	Uint32  *uint32  `protobuf:"4"`
+	Uint64  *uint64  `protobuf:"5"`
+	Float32 *float32 `protobuf:"6"`
+	Float64 *float64 `protobuf:"7"`
+	String  *string  `protobuf:"8"`
+	StringA []byte   `protobuf:"9"`
+	Bytes   []byte   `protobuf:"10"`
+	BytesA  *string  `protobuf:"11"`
+
+	MyBool    *MyBool    `protobuf:"12"`
+	MyInt32   *MyInt32   `protobuf:"13"`
+	MyInt64   *MyInt64   `protobuf:"14"`
+	MyUint32  *MyUint32  `protobuf:"15"`
+	MyUint64  *MyUint64  `protobuf:"16"`
+	MyFloat32 *MyFloat32 `protobuf:"17"`
+	MyFloat64 *MyFloat64 `protobuf:"18"`
+	MyString  *MyString  `protobuf:"19"`
+	MyStringA MyBytes    `protobuf:"20"`
+	MyBytes   MyBytes    `protobuf:"21"`
+	MyBytesA  *MyString  `protobuf:"22"`
+}
 
+func TestScalarProto2(t *testing.T) {
 	mi := MessageType{Desc: mustMakeMessageDesc(ptype.StandaloneMessage{
 		Syntax:   pref.Proto2,
 		FullName: "ScalarProto2",
@@ -182,33 +203,33 @@ func TestScalarProto2(t *testing.T) {
 	})
 }
 
-func TestScalarProto3(t *testing.T) {
-	type ScalarProto3 struct {
-		Bool    bool    `protobuf:"1"`
-		Int32   int32   `protobuf:"2"`
-		Int64   int64   `protobuf:"3"`
-		Uint32  uint32  `protobuf:"4"`
-		Uint64  uint64  `protobuf:"5"`
-		Float32 float32 `protobuf:"6"`
-		Float64 float64 `protobuf:"7"`
-		String  string  `protobuf:"8"`
-		StringA []byte  `protobuf:"9"`
-		Bytes   []byte  `protobuf:"10"`
-		BytesA  string  `protobuf:"11"`
-
-		MyBool    MyBool    `protobuf:"12"`
-		MyInt32   MyInt32   `protobuf:"13"`
-		MyInt64   MyInt64   `protobuf:"14"`
-		MyUint32  MyUint32  `protobuf:"15"`
-		MyUint64  MyUint64  `protobuf:"16"`
-		MyFloat32 MyFloat32 `protobuf:"17"`
-		MyFloat64 MyFloat64 `protobuf:"18"`
-		MyString  MyString  `protobuf:"19"`
-		MyStringA MyBytes   `protobuf:"20"`
-		MyBytes   MyBytes   `protobuf:"21"`
-		MyBytesA  MyString  `protobuf:"22"`
-	}
+type ScalarProto3 struct {
+	Bool    bool    `protobuf:"1"`
+	Int32   int32   `protobuf:"2"`
+	Int64   int64   `protobuf:"3"`
+	Uint32  uint32  `protobuf:"4"`
+	Uint64  uint64  `protobuf:"5"`
+	Float32 float32 `protobuf:"6"`
+	Float64 float64 `protobuf:"7"`
+	String  string  `protobuf:"8"`
+	StringA []byte  `protobuf:"9"`
+	Bytes   []byte  `protobuf:"10"`
+	BytesA  string  `protobuf:"11"`
+
+	MyBool    MyBool    `protobuf:"12"`
+	MyInt32   MyInt32   `protobuf:"13"`
+	MyInt64   MyInt64   `protobuf:"14"`
+	MyUint32  MyUint32  `protobuf:"15"`
+	MyUint64  MyUint64  `protobuf:"16"`
+	MyFloat32 MyFloat32 `protobuf:"17"`
+	MyFloat64 MyFloat64 `protobuf:"18"`
+	MyString  MyString  `protobuf:"19"`
+	MyStringA MyBytes   `protobuf:"20"`
+	MyBytes   MyBytes   `protobuf:"21"`
+	MyBytesA  MyString  `protobuf:"22"`
+}
 
+func TestScalarProto3(t *testing.T) {
 	mi := MessageType{Desc: mustMakeMessageDesc(ptype.StandaloneMessage{
 		Syntax:   pref.Proto3,
 		FullName: "ScalarProto3",
@@ -277,31 +298,31 @@ func TestScalarProto3(t *testing.T) {
 	})
 }
 
-func TestRepeatedScalars(t *testing.T) {
-	type RepeatedScalars struct {
-		Bools    []bool    `protobuf:"1"`
-		Int32s   []int32   `protobuf:"2"`
-		Int64s   []int64   `protobuf:"3"`
-		Uint32s  []uint32  `protobuf:"4"`
-		Uint64s  []uint64  `protobuf:"5"`
-		Float32s []float32 `protobuf:"6"`
-		Float64s []float64 `protobuf:"7"`
-		Strings  []string  `protobuf:"8"`
-		StringsA [][]byte  `protobuf:"9"`
-		Bytes    [][]byte  `protobuf:"10"`
-		BytesA   []string  `protobuf:"11"`
-
-		MyStrings1 []MyString `protobuf:"12"`
-		MyStrings2 []MyBytes  `protobuf:"13"`
-		MyBytes1   []MyBytes  `protobuf:"14"`
-		MyBytes2   []MyString `protobuf:"15"`
-
-		MyStrings3 NamedStrings `protobuf:"16"`
-		MyStrings4 NamedBytes   `protobuf:"17"`
-		MyBytes3   NamedBytes   `protobuf:"18"`
-		MyBytes4   NamedStrings `protobuf:"19"`
-	}
+type RepeatedScalars struct {
+	Bools    []bool    `protobuf:"1"`
+	Int32s   []int32   `protobuf:"2"`
+	Int64s   []int64   `protobuf:"3"`
+	Uint32s  []uint32  `protobuf:"4"`
+	Uint64s  []uint64  `protobuf:"5"`
+	Float32s []float32 `protobuf:"6"`
+	Float64s []float64 `protobuf:"7"`
+	Strings  []string  `protobuf:"8"`
+	StringsA [][]byte  `protobuf:"9"`
+	Bytes    [][]byte  `protobuf:"10"`
+	BytesA   []string  `protobuf:"11"`
+
+	MyStrings1 []MyString `protobuf:"12"`
+	MyStrings2 []MyBytes  `protobuf:"13"`
+	MyBytes1   []MyBytes  `protobuf:"14"`
+	MyBytes2   []MyString `protobuf:"15"`
+
+	MyStrings3 VectorStrings `protobuf:"16"`
+	MyStrings4 VectorBytes   `protobuf:"17"`
+	MyBytes3   VectorBytes   `protobuf:"18"`
+	MyBytes4   VectorStrings `protobuf:"19"`
+}
 
+func TestRepeatedScalars(t *testing.T) {
 	mi := MessageType{Desc: mustMakeMessageDesc(ptype.StandaloneMessage{
 		Syntax:   pref.Proto2,
 		FullName: "RepeatedScalars",
@@ -351,10 +372,10 @@ func TestRepeatedScalars(t *testing.T) {
 		MyBytes1:   []MyBytes{[]byte("14"), nil, []byte("fourteen")},
 		MyBytes2:   []MyString{"15", "", "fifteen"},
 
-		MyStrings3: NamedStrings{"16", "", "sixteen"},
-		MyStrings4: NamedBytes{[]byte("17"), nil, []byte("seventeen")},
-		MyBytes3:   NamedBytes{[]byte("18"), nil, []byte("eighteen")},
-		MyBytes4:   NamedStrings{"19", "", "nineteen"},
+		MyStrings3: VectorStrings{"16", "", "sixteen"},
+		MyStrings4: VectorBytes{[]byte("17"), nil, []byte("seventeen")},
+		MyBytes3:   VectorBytes{[]byte("18"), nil, []byte("eighteen")},
+		MyBytes4:   VectorStrings{"19", "", "nineteen"},
 	})
 	wantFS := want.KnownFields()
 
@@ -418,38 +439,38 @@ func TestRepeatedScalars(t *testing.T) {
 	})
 }
 
-func TestMapScalars(t *testing.T) {
-	type MapScalars struct {
-		KeyBools   map[bool]string   `protobuf:"1"`
-		KeyInt32s  map[int32]string  `protobuf:"2"`
-		KeyInt64s  map[int64]string  `protobuf:"3"`
-		KeyUint32s map[uint32]string `protobuf:"4"`
-		KeyUint64s map[uint64]string `protobuf:"5"`
-		KeyStrings map[string]string `protobuf:"6"`
-
-		ValBools    map[string]bool    `protobuf:"7"`
-		ValInt32s   map[string]int32   `protobuf:"8"`
-		ValInt64s   map[string]int64   `protobuf:"9"`
-		ValUint32s  map[string]uint32  `protobuf:"10"`
-		ValUint64s  map[string]uint64  `protobuf:"11"`
-		ValFloat32s map[string]float32 `protobuf:"12"`
-		ValFloat64s map[string]float64 `protobuf:"13"`
-		ValStrings  map[string]string  `protobuf:"14"`
-		ValStringsA map[string][]byte  `protobuf:"15"`
-		ValBytes    map[string][]byte  `protobuf:"16"`
-		ValBytesA   map[string]string  `protobuf:"17"`
-
-		MyStrings1 map[MyString]MyString `protobuf:"18"`
-		MyStrings2 map[MyString]MyBytes  `protobuf:"19"`
-		MyBytes1   map[MyString]MyBytes  `protobuf:"20"`
-		MyBytes2   map[MyString]MyString `protobuf:"21"`
-
-		MyStrings3 MapStrings `protobuf:"22"`
-		MyStrings4 MapBytes   `protobuf:"23"`
-		MyBytes3   MapBytes   `protobuf:"24"`
-		MyBytes4   MapStrings `protobuf:"25"`
-	}
+type MapScalars struct {
+	KeyBools   map[bool]string   `protobuf:"1"`
+	KeyInt32s  map[int32]string  `protobuf:"2"`
+	KeyInt64s  map[int64]string  `protobuf:"3"`
+	KeyUint32s map[uint32]string `protobuf:"4"`
+	KeyUint64s map[uint64]string `protobuf:"5"`
+	KeyStrings map[string]string `protobuf:"6"`
+
+	ValBools    map[string]bool    `protobuf:"7"`
+	ValInt32s   map[string]int32   `protobuf:"8"`
+	ValInt64s   map[string]int64   `protobuf:"9"`
+	ValUint32s  map[string]uint32  `protobuf:"10"`
+	ValUint64s  map[string]uint64  `protobuf:"11"`
+	ValFloat32s map[string]float32 `protobuf:"12"`
+	ValFloat64s map[string]float64 `protobuf:"13"`
+	ValStrings  map[string]string  `protobuf:"14"`
+	ValStringsA map[string][]byte  `protobuf:"15"`
+	ValBytes    map[string][]byte  `protobuf:"16"`
+	ValBytesA   map[string]string  `protobuf:"17"`
+
+	MyStrings1 map[MyString]MyString `protobuf:"18"`
+	MyStrings2 map[MyString]MyBytes  `protobuf:"19"`
+	MyBytes1   map[MyString]MyBytes  `protobuf:"20"`
+	MyBytes2   map[MyString]MyString `protobuf:"21"`
+
+	MyStrings3 MapStrings `protobuf:"22"`
+	MyStrings4 MapBytes   `protobuf:"23"`
+	MyBytes3   MapBytes   `protobuf:"24"`
+	MyBytes4   MapStrings `protobuf:"25"`
+}
 
+func TestMapScalars(t *testing.T) {
 	mustMakeMapEntry := func(n pref.FieldNumber, keyKind, valKind pref.Kind) ptype.Field {
 		return ptype.Field{
 			Name:        pref.Name(fmt.Sprintf("f%d", n)),