internal/value: extract Vector and Map logic as separate package

The implementation of reflect/protoreflect.NewGoExtension needs to be able to
provide a constructor for wrapping *[]T as a protoreflect.Vector.
However, it cannot depend on internal/impl since impl also depends on prototype.
Extract the common logic of Vector creation into a separate package that
has no dependencies on either impl or prototype.

Change-Id: I9295fde9b8861de11af085c91d9dfa56047d1b1e
Reviewed-on: https://go-review.googlesource.com/c/147446
Reviewed-by: Herbie Ong <herbie@google.com>

internal/impl/legacy_unknown.go

@@ -13,6 +13,8 @@ import (
 	pref "github.com/golang/protobuf/v2/reflect/protoreflect"
 )
 
+var bytesType = reflect.TypeOf([]byte(nil))
+
 func makeLegacyUnknownFieldsFunc(t reflect.Type) func(p *messageDataType) pref.UnknownFields {
 	fu, ok := t.FieldByName("XXX_unrecognized")
 	if !ok || fu.Type != bytesType {

internal/impl/message_field.go

@@ -9,6 +9,7 @@ import (
 	"reflect"
 
 	"github.com/golang/protobuf/v2/internal/flags"
+	"github.com/golang/protobuf/v2/internal/value"
 	pref "github.com/golang/protobuf/v2/reflect/protoreflect"
 )
 
@@ -41,7 +42,7 @@ func fieldInfoForOneof(fd pref.FieldDescriptor, fs reflect.StructField, ot refle
 	if !reflect.PtrTo(ot).Implements(ft) {
 		panic(fmt.Sprintf("invalid type: %v does not implement %v", ot, ft))
 	}
-	conv := matchGoTypePBKind(ot.Field(0).Type, fd.Kind())
+	conv := value.NewLegacyConverter(ot.Field(0).Type, fd.Kind(), wrapLegacyMessage)
 	fieldOffset := offsetOf(fs)
 	// TODO: Implement unsafe fast path?
 	return fieldInfo{
@@ -62,12 +63,12 @@ func fieldInfoForOneof(fd pref.FieldDescriptor, fs reflect.StructField, ot refle
 				if fd.Kind() == pref.MessageKind || fd.Kind() == pref.GroupKind {
 					// TODO: Should this return an invalid protoreflect.Value?
 					rv = reflect.Zero(ot.Field(0).Type)
-					return conv.toPB(rv)
+					return conv.PBValueOf(rv)
 				}
 				return fd.Default()
 			}
 			rv = rv.Elem().Elem().Field(0)
-			return conv.toPB(rv)
+			return conv.PBValueOf(rv)
 		},
 		set: func(p pointer, v pref.Value) {
 			rv := p.apply(fieldOffset).asType(fs.Type).Elem()
@@ -75,7 +76,7 @@ func fieldInfoForOneof(fd pref.FieldDescriptor, fs reflect.StructField, ot refle
 				rv.Set(reflect.New(ot))
 			}
 			rv = rv.Elem().Elem().Field(0)
-			rv.Set(conv.toGo(v))
+			rv.Set(conv.GoValueOf(v))
 		},
 		clear: func(p pointer) {
 			rv := p.apply(fieldOffset).asType(fs.Type).Elem()
@@ -92,8 +93,8 @@ func fieldInfoForOneof(fd pref.FieldDescriptor, fs reflect.StructField, ot refle
 			}
 			rv = rv.Elem().Elem().Field(0)
 			if rv.IsNil() {
-				pv := pref.ValueOf(conv.newMessage())
-				rv.Set(conv.toGo(pv))
+				pv := pref.ValueOf(conv.NewMessage())
+				rv.Set(conv.GoValueOf(pv))
 			}
 			return rv.Interface().(pref.Message)
 		},
@@ -105,8 +106,8 @@ func fieldInfoForMap(fd pref.FieldDescriptor, fs reflect.StructField) fieldInfo
 	if ft.Kind() != reflect.Map {
 		panic(fmt.Sprintf("invalid type: got %v, want map kind", ft))
 	}
-	keyConv := matchGoTypePBKind(ft.Key(), fd.MessageType().Fields().ByNumber(1).Kind())
-	valConv := matchGoTypePBKind(ft.Elem(), fd.MessageType().Fields().ByNumber(2).Kind())
+	keyConv := value.NewLegacyConverter(ft.Key(), fd.MessageType().Fields().ByNumber(1).Kind(), wrapLegacyMessage)
+	valConv := value.NewLegacyConverter(ft.Elem(), fd.MessageType().Fields().ByNumber(2).Kind(), wrapLegacyMessage)
 	fieldOffset := offsetOf(fs)
 	// TODO: Implement unsafe fast path?
 	return fieldInfo{
@@ -115,96 +116,30 @@ func fieldInfoForMap(fd pref.FieldDescriptor, fs reflect.StructField) fieldInfo
 			return rv.Len() > 0
 		},
 		get: func(p pointer) pref.Value {
-			rv := p.apply(fieldOffset).asType(fs.Type).Elem()
-			return pref.ValueOf(mapReflect{rv, keyConv, valConv})
+			v := p.apply(fieldOffset).asType(fs.Type).Interface()
+			return pref.ValueOf(value.MapOf(v, keyConv, valConv))
 		},
 		set: func(p pointer, v pref.Value) {
 			rv := p.apply(fieldOffset).asType(fs.Type).Elem()
-			rv.Set(v.Map().(mapReflect).v)
+			rv.Set(reflect.ValueOf(v.Map().(value.Unwrapper).Unwrap()))
 		},
 		clear: func(p pointer) {
 			rv := p.apply(fieldOffset).asType(fs.Type).Elem()
 			rv.Set(reflect.Zero(rv.Type()))
 		},
 		mutable: func(p pointer) pref.Mutable {
-			rv := p.apply(fieldOffset).asType(fs.Type).Elem()
-			return mapReflect{rv, keyConv, valConv}
+			v := p.apply(fieldOffset).asType(fs.Type).Interface()
+			return value.MapOf(v, keyConv, valConv)
 		},
 	}
 }
 
-type mapReflect struct {
-	v       reflect.Value // addressable map[K]V
-	keyConv converter
-	valConv converter
-}
-
-func (ms mapReflect) Len() int {
-	return ms.v.Len()
-}
-func (ms mapReflect) Has(k pref.MapKey) bool {
-	rk := ms.keyConv.toGo(k.Value())
-	rv := ms.v.MapIndex(rk)
-	return rv.IsValid()
-}
-func (ms mapReflect) Get(k pref.MapKey) pref.Value {
-	rk := ms.keyConv.toGo(k.Value())
-	rv := ms.v.MapIndex(rk)
-	if !rv.IsValid() {
-		return pref.Value{}
-	}
-	return ms.valConv.toPB(rv)
-}
-func (ms mapReflect) Set(k pref.MapKey, v pref.Value) {
-	if ms.v.IsNil() {
-		ms.v.Set(reflect.MakeMap(ms.v.Type()))
-	}
-	rk := ms.keyConv.toGo(k.Value())
-	rv := ms.valConv.toGo(v)
-	ms.v.SetMapIndex(rk, rv)
-}
-func (ms mapReflect) Clear(k pref.MapKey) {
-	rk := ms.keyConv.toGo(k.Value())
-	ms.v.SetMapIndex(rk, reflect.Value{})
-}
-func (ms mapReflect) Mutable(k pref.MapKey) pref.Mutable {
-	// Mutable is only valid for messages and panics for other kinds.
-	if ms.v.IsNil() {
-		ms.v.Set(reflect.MakeMap(ms.v.Type()))
-	}
-	rk := ms.keyConv.toGo(k.Value())
-	rv := ms.v.MapIndex(rk)
-	if !rv.IsValid() || rv.IsNil() {
-		pv := pref.ValueOf(ms.valConv.newMessage())
-		rv = ms.valConv.toGo(pv)
-		ms.v.SetMapIndex(rk, rv)
-	}
-	return rv.Interface().(pref.Message)
-}
-func (ms mapReflect) Range(f func(pref.MapKey, pref.Value) bool) {
-	for _, k := range ms.v.MapKeys() {
-		if v := ms.v.MapIndex(k); v.IsValid() {
-			pk := ms.keyConv.toPB(k).MapKey()
-			pv := ms.valConv.toPB(v)
-			if !f(pk, pv) {
-				return
-			}
-		}
-	}
-}
-func (ms mapReflect) Unwrap() interface{} { // TODO: unexport?
-	return ms.v.Interface()
-}
-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 {
 		panic(fmt.Sprintf("invalid type: got %v, want slice kind", ft))
 	}
-	conv := matchGoTypePBKind(ft.Elem(), fd.Kind())
+	conv := value.NewLegacyConverter(ft.Elem(), fd.Kind(), wrapLegacyMessage)
 	fieldOffset := offsetOf(fs)
 	// TODO: Implement unsafe fast path?
 	return fieldInfo{
@@ -213,66 +148,24 @@ func fieldInfoForVector(fd pref.FieldDescriptor, fs reflect.StructField) fieldIn
 			return rv.Len() > 0
 		},
 		get: func(p pointer) pref.Value {
-			rv := p.apply(fieldOffset).asType(fs.Type).Elem()
-			return pref.ValueOf(vectorReflect{rv, conv})
+			v := p.apply(fieldOffset).asType(fs.Type).Interface()
+			return pref.ValueOf(value.VectorOf(v, conv))
 		},
 		set: func(p pointer, v pref.Value) {
 			rv := p.apply(fieldOffset).asType(fs.Type).Elem()
-			rv.Set(v.Vector().(vectorReflect).v)
+			rv.Set(reflect.ValueOf(v.Vector().(value.Unwrapper).Unwrap()))
 		},
 		clear: func(p pointer) {
 			rv := p.apply(fieldOffset).asType(fs.Type).Elem()
 			rv.Set(reflect.Zero(rv.Type()))
 		},
 		mutable: func(p pointer) pref.Mutable {
-			rv := p.apply(fieldOffset).asType(fs.Type).Elem()
-			return vectorReflect{rv, conv}
+			v := p.apply(fieldOffset).asType(fs.Type).Interface()
+			return value.VectorOf(v, conv)
 		},
 	}
 }
 
-type vectorReflect struct {
-	v    reflect.Value // addressable []T
-	conv converter
-}
-
-func (vs vectorReflect) Len() int {
-	return vs.v.Len()
-}
-func (vs vectorReflect) Get(i int) pref.Value {
-	return vs.conv.toPB(vs.v.Index(i))
-}
-func (vs vectorReflect) Set(i int, v pref.Value) {
-	vs.v.Index(i).Set(vs.conv.toGo(v))
-}
-func (vs vectorReflect) Append(v pref.Value) {
-	vs.v.Set(reflect.Append(vs.v, vs.conv.toGo(v)))
-}
-func (vs vectorReflect) Mutable(i int) pref.Mutable {
-	// Mutable is only valid for messages and panics for other kinds.
-	rv := vs.v.Index(i)
-	if rv.IsNil() {
-		pv := pref.ValueOf(vs.conv.newMessage())
-		rv.Set(vs.conv.toGo(pv))
-	}
-	return rv.Interface().(pref.Message)
-}
-func (vs vectorReflect) MutableAppend() pref.Mutable {
-	// MutableAppend is only valid for messages and panics for other kinds.
-	pv := pref.ValueOf(vs.conv.newMessage())
-	vs.v.Set(reflect.Append(vs.v, vs.conv.toGo(pv)))
-	return vs.v.Index(vs.Len() - 1).Interface().(pref.Message)
-}
-func (vs vectorReflect) Truncate(i int) {
-	vs.v.Set(vs.v.Slice(0, i))
-}
-func (vs vectorReflect) Unwrap() interface{} { // TODO: unexport?
-	return vs.v.Interface()
-}
-func (vs vectorReflect) ProtoMutable() {}
-
-var _ pref.Vector = vectorReflect{}
-
 var emptyBytes = reflect.ValueOf([]byte{})
 
 func fieldInfoForScalar(fd pref.FieldDescriptor, fs reflect.StructField) fieldInfo {
@@ -286,7 +179,7 @@ func fieldInfoForScalar(fd pref.FieldDescriptor, fs reflect.StructField) fieldIn
 			ft = ft.Elem()
 		}
 	}
-	conv := matchGoTypePBKind(ft, fd.Kind())
+	conv := value.NewLegacyConverter(ft, fd.Kind(), wrapLegacyMessage)
 	fieldOffset := offsetOf(fs)
 	// TODO: Implement unsafe fast path?
 	return fieldInfo{
@@ -324,7 +217,7 @@ func fieldInfoForScalar(fd pref.FieldDescriptor, fs reflect.StructField) fieldIn
 					rv = rv.Elem()
 				}
 			}
-			return conv.toPB(rv)
+			return conv.PBValueOf(rv)
 		},
 		set: func(p pointer, v pref.Value) {
 			rv := p.apply(fieldOffset).asType(fs.Type).Elem()
@@ -334,7 +227,7 @@ func fieldInfoForScalar(fd pref.FieldDescriptor, fs reflect.StructField) fieldIn
 				}
 				rv = rv.Elem()
 			}
-			rv.Set(conv.toGo(v))
+			rv.Set(conv.GoValueOf(v))
 			if nullable && rv.Kind() == reflect.Slice && rv.IsNil() {
 				rv.Set(emptyBytes)
 			}
@@ -351,7 +244,7 @@ func fieldInfoForScalar(fd pref.FieldDescriptor, fs reflect.StructField) fieldIn
 
 func fieldInfoForMessage(fd pref.FieldDescriptor, fs reflect.StructField) fieldInfo {
 	ft := fs.Type
-	conv := matchGoTypePBKind(ft, fd.Kind())
+	conv := value.NewLegacyConverter(ft, fd.Kind(), wrapLegacyMessage)
 	fieldOffset := offsetOf(fs)
 	// TODO: Implement unsafe fast path?
 	return fieldInfo{
@@ -367,12 +260,12 @@ func fieldInfoForMessage(fd pref.FieldDescriptor, fs reflect.StructField) fieldI
 			// 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)
+			return conv.PBValueOf(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))
+			rv.Set(conv.GoValueOf(v))
 		},
 		clear: func(p pointer) {
 			rv := p.apply(fieldOffset).asType(fs.Type).Elem()
@@ -382,196 +275,10 @@ func fieldInfoForMessage(fd pref.FieldDescriptor, fs reflect.StructField) fieldI
 			// 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.
-type messageV1 interface {
-	Reset()
-	String() string
-	ProtoMessage()
-}
-
-var (
-	boolType    = reflect.TypeOf(bool(false))
-	int32Type   = reflect.TypeOf(int32(0))
-	int64Type   = reflect.TypeOf(int64(0))
-	uint32Type  = reflect.TypeOf(uint32(0))
-	uint64Type  = reflect.TypeOf(uint64(0))
-	float32Type = reflect.TypeOf(float32(0))
-	float64Type = reflect.TypeOf(float64(0))
-	stringType  = reflect.TypeOf(string(""))
-	bytesType   = reflect.TypeOf([]byte(nil))
-
-	enumIfaceV2    = reflect.TypeOf((*pref.ProtoEnum)(nil)).Elem()
-	messageIfaceV1 = reflect.TypeOf((*messageV1)(nil)).Elem()
-	messageIfaceV2 = reflect.TypeOf((*pref.ProtoMessage)(nil)).Elem()
-
-	byteType = reflect.TypeOf(byte(0))
-)
-
-// matchGoTypePBKind matches a Go type with the protobuf kind.
-//
-// This matcher deliberately supports a wider range of Go types than what
-// protoc-gen-go historically generated to be able to automatically wrap some
-// v1 messages generated by other forks of protoc-gen-go.
-func matchGoTypePBKind(t reflect.Type, k pref.Kind) converter {
-	switch k {
-	case pref.BoolKind:
-		if t.Kind() == reflect.Bool {
-			return makeScalarConverter(t, boolType)
-		}
-	case pref.Int32Kind, pref.Sint32Kind, pref.Sfixed32Kind:
-		if t.Kind() == reflect.Int32 {
-			return makeScalarConverter(t, int32Type)
-		}
-	case pref.Int64Kind, pref.Sint64Kind, pref.Sfixed64Kind:
-		if t.Kind() == reflect.Int64 {
-			return makeScalarConverter(t, int64Type)
-		}
-	case pref.Uint32Kind, pref.Fixed32Kind:
-		if t.Kind() == reflect.Uint32 {
-			return makeScalarConverter(t, uint32Type)
-		}
-	case pref.Uint64Kind, pref.Fixed64Kind:
-		if t.Kind() == reflect.Uint64 {
-			return makeScalarConverter(t, uint64Type)
-		}
-	case pref.FloatKind:
-		if t.Kind() == reflect.Float32 {
-			return makeScalarConverter(t, float32Type)
-		}
-	case pref.DoubleKind:
-		if t.Kind() == reflect.Float64 {
-			return makeScalarConverter(t, float64Type)
-		}
-	case pref.StringKind:
-		if t.Kind() == reflect.String || (t.Kind() == reflect.Slice && t.Elem() == byteType) {
-			return makeScalarConverter(t, stringType)
-		}
-	case pref.BytesKind:
-		if t.Kind() == reflect.String || (t.Kind() == reflect.Slice && t.Elem() == byteType) {
-			return makeScalarConverter(t, bytesType)
-		}
-	case pref.EnumKind:
-		// Handle v2 enums, which must satisfy the proto.Enum interface.
-		if t.Kind() != reflect.Ptr && t.Implements(enumIfaceV2) {
-			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() != "" {
-			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) {
-			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) {
-			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))
-}
-
-// converter provides functions for converting to/from Go reflect.Value types
-// and protobuf protoreflect.Value types.
-type converter struct {
-	toPB       func(reflect.Value) pref.Value
-	toGo       func(pref.Value) reflect.Value
-	newMessage func() pref.Message
-}
-
-func makeScalarConverter(goType, pbType reflect.Type) converter {
-	return converter{
-		toPB: func(v reflect.Value) pref.Value {
-			if v.Type() != goType {
-				panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), goType))
-			}
-			if goType.Kind() == reflect.String && pbType.Kind() == reflect.Slice && v.Len() == 0 {
-				return pref.ValueOf([]byte(nil)) // ensure empty string is []byte(nil)
-			}
-			return pref.ValueOf(v.Convert(pbType).Interface())
-		},
-		toGo: func(v pref.Value) reflect.Value {
-			rv := reflect.ValueOf(v.Interface())
-			if rv.Type() != pbType {
-				panic(fmt.Sprintf("invalid type: got %v, want %v", rv.Type(), pbType))
-			}
-			if pbType.Kind() == reflect.String && goType.Kind() == reflect.Slice && rv.Len() == 0 {
-				return reflect.Zero(goType) // ensure empty string is []byte(nil)
+				pv := pref.ValueOf(conv.NewMessage())
+				rv.Set(conv.GoValueOf(pv))
 			}
-			return rv.Convert(goType)
+			return conv.PBValueOf(rv).Message()
 		},
 	}
 }

internal/value/convert.go

@@ -0,0 +1,220 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package value provides functionality for wrapping Go values to implement
+// protoreflect values.
+package value
+
+import (
+	"fmt"
+	"reflect"
+
+	pref "github.com/golang/protobuf/v2/reflect/protoreflect"
+)
+
+// Unwrapper unwraps the value to the underlying value.
+// This is implemented by Vector and Map.
+type Unwrapper interface {
+	Unwrap() interface{}
+}
+
+// messageV1 is the protoV1.Message interface.
+type messageV1 = interface {
+	Reset()
+	String() string
+	ProtoMessage()
+}
+
+var (
+	boolType    = reflect.TypeOf(bool(false))
+	int32Type   = reflect.TypeOf(int32(0))
+	int64Type   = reflect.TypeOf(int64(0))
+	uint32Type  = reflect.TypeOf(uint32(0))
+	uint64Type  = reflect.TypeOf(uint64(0))
+	float32Type = reflect.TypeOf(float32(0))
+	float64Type = reflect.TypeOf(float64(0))
+	stringType  = reflect.TypeOf(string(""))
+	bytesType   = reflect.TypeOf([]byte(nil))
+
+	enumIfaceV2    = reflect.TypeOf((*pref.ProtoEnum)(nil)).Elem()
+	messageIfaceV1 = reflect.TypeOf((*messageV1)(nil)).Elem()
+	messageIfaceV2 = reflect.TypeOf((*pref.ProtoMessage)(nil)).Elem()
+
+	byteType = reflect.TypeOf(byte(0))
+)
+
+// NewConverter matches a Go type with a protobuf kind and returns a Converter
+// that converts between the two. NewConverter panics if it unable to provide a
+// conversion between the two. The Converter methods also panic when they are
+// called on incorrect Go types.
+//
+// This matcher deliberately supports a wider range of Go types than what
+// protoc-gen-go historically generated to be able to automatically wrap some
+// v1 messages generated by other forks of protoc-gen-go.
+func NewConverter(t reflect.Type, k pref.Kind) Converter {
+	return NewLegacyConverter(t, k, nil)
+}
+
+// NewLegacyConverter is identical to NewConverter,
+// but supports wrapping legacy v1 messages to implement the v2 message API
+// using the provided wrapLegacyMessage function.
+// The wrapped message must implement Unwrapper.
+func NewLegacyConverter(t reflect.Type, k pref.Kind, wrapLegacyMessage func(reflect.Value) pref.Message) Converter {
+	switch k {
+	case pref.BoolKind:
+		if t.Kind() == reflect.Bool {
+			return makeScalarConverter(t, boolType)
+		}
+	case pref.Int32Kind, pref.Sint32Kind, pref.Sfixed32Kind:
+		if t.Kind() == reflect.Int32 {
+			return makeScalarConverter(t, int32Type)
+		}
+	case pref.Int64Kind, pref.Sint64Kind, pref.Sfixed64Kind:
+		if t.Kind() == reflect.Int64 {
+			return makeScalarConverter(t, int64Type)
+		}
+	case pref.Uint32Kind, pref.Fixed32Kind:
+		if t.Kind() == reflect.Uint32 {
+			return makeScalarConverter(t, uint32Type)
+		}
+	case pref.Uint64Kind, pref.Fixed64Kind:
+		if t.Kind() == reflect.Uint64 {
+			return makeScalarConverter(t, uint64Type)
+		}
+	case pref.FloatKind:
+		if t.Kind() == reflect.Float32 {
+			return makeScalarConverter(t, float32Type)
+		}
+	case pref.DoubleKind:
+		if t.Kind() == reflect.Float64 {
+			return makeScalarConverter(t, float64Type)
+		}
+	case pref.StringKind:
+		if t.Kind() == reflect.String || (t.Kind() == reflect.Slice && t.Elem() == byteType) {
+			return makeScalarConverter(t, stringType)
+		}
+	case pref.BytesKind:
+		if t.Kind() == reflect.String || (t.Kind() == reflect.Slice && t.Elem() == byteType) {
+			return makeScalarConverter(t, bytesType)
+		}
+	case pref.EnumKind:
+		// Handle v2 enums, which must satisfy the proto.Enum interface.
+		if t.Kind() != reflect.Ptr && t.Implements(enumIfaceV2) {
+			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 wrapLegacyMessage != nil && t.Kind() == reflect.Int32 && t.PkgPath() != "" {
+			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) {
+			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 wrapLegacyMessage != nil && t.Kind() == reflect.Ptr && t.Implements(messageIfaceV1) {
+			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 {
+					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))
+}
+
+func makeScalarConverter(goType, pbType reflect.Type) Converter {
+	return Converter{
+		toPB: func(v reflect.Value) pref.Value {
+			if v.Type() != goType {
+				panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), goType))
+			}
+			if goType.Kind() == reflect.String && pbType.Kind() == reflect.Slice && v.Len() == 0 {
+				return pref.ValueOf([]byte(nil)) // ensure empty string is []byte(nil)
+			}
+			return pref.ValueOf(v.Convert(pbType).Interface())
+		},
+		toGo: func(v pref.Value) reflect.Value {
+			rv := reflect.ValueOf(v.Interface())
+			if rv.Type() != pbType {
+				panic(fmt.Sprintf("invalid type: got %v, want %v", rv.Type(), pbType))
+			}
+			if pbType.Kind() == reflect.String && goType.Kind() == reflect.Slice && rv.Len() == 0 {
+				return reflect.Zero(goType) // ensure empty string is []byte(nil)
+			}
+			return rv.Convert(goType)
+		},
+	}
+}
+
+// Converter provides functions for converting to/from Go reflect.Value types
+// and protobuf protoreflect.Value types.
+type Converter struct {
+	toPB       func(reflect.Value) pref.Value
+	toGo       func(pref.Value) reflect.Value
+	newMessage func() pref.Message
+}
+
+func (c Converter) PBValueOf(v reflect.Value) pref.Value { return c.toPB(v) }
+func (c Converter) GoValueOf(v pref.Value) reflect.Value { return c.toGo(v) }
+func (c Converter) NewMessage() pref.Message             { return c.newMessage() }

internal/value/map.go

@@ -0,0 +1,87 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package value
+
+import (
+	"reflect"
+
+	pref "github.com/golang/protobuf/v2/reflect/protoreflect"
+)
+
+func MapOf(p interface{}, kc, kv Converter) pref.Map {
+	// TODO: Validate that p is a *map[K]V?
+	rv := reflect.ValueOf(p).Elem()
+	return mapReflect{rv, kc, kv}
+}
+
+type mapReflect struct {
+	v       reflect.Value // addressable map[K]V
+	keyConv Converter
+	valConv Converter
+}
+
+func (ms mapReflect) Len() int {
+	return ms.v.Len()
+}
+func (ms mapReflect) Has(k pref.MapKey) bool {
+	rk := ms.keyConv.GoValueOf(k.Value())
+	rv := ms.v.MapIndex(rk)
+	return rv.IsValid()
+}
+func (ms mapReflect) Get(k pref.MapKey) pref.Value {
+	rk := ms.keyConv.GoValueOf(k.Value())
+	rv := ms.v.MapIndex(rk)
+	if !rv.IsValid() {
+		return pref.Value{}
+	}
+	return ms.valConv.PBValueOf(rv)
+}
+func (ms mapReflect) Set(k pref.MapKey, v pref.Value) {
+	if ms.v.IsNil() {
+		ms.v.Set(reflect.MakeMap(ms.v.Type()))
+	}
+	rk := ms.keyConv.GoValueOf(k.Value())
+	rv := ms.valConv.GoValueOf(v)
+	ms.v.SetMapIndex(rk, rv)
+}
+func (ms mapReflect) Clear(k pref.MapKey) {
+	rk := ms.keyConv.GoValueOf(k.Value())
+	ms.v.SetMapIndex(rk, reflect.Value{})
+}
+func (ms mapReflect) Mutable(k pref.MapKey) pref.Mutable {
+	// Mutable is only valid for messages and panics for other kinds.
+	if ms.v.IsNil() {
+		ms.v.Set(reflect.MakeMap(ms.v.Type()))
+	}
+	rk := ms.keyConv.GoValueOf(k.Value())
+	rv := ms.v.MapIndex(rk)
+	if !rv.IsValid() || rv.IsNil() {
+		// TODO: Is checking for nil proper behavior for custom messages?
+		pv := pref.ValueOf(ms.valConv.NewMessage())
+		rv = ms.valConv.GoValueOf(pv)
+		ms.v.SetMapIndex(rk, rv)
+	}
+	return rv.Interface().(pref.Message)
+}
+func (ms mapReflect) Range(f func(pref.MapKey, pref.Value) bool) {
+	for _, k := range ms.v.MapKeys() {
+		if v := ms.v.MapIndex(k); v.IsValid() {
+			pk := ms.keyConv.PBValueOf(k).MapKey()
+			pv := ms.valConv.PBValueOf(v)
+			if !f(pk, pv) {
+				return
+			}
+		}
+	}
+}
+func (ms mapReflect) Unwrap() interface{} {
+	return ms.v.Interface()
+}
+func (ms mapReflect) ProtoMutable() {}
+
+var (
+	_ pref.Map  = mapReflect{}
+	_ Unwrapper = mapReflect{}
+)

internal/value/vector.go

@@ -0,0 +1,63 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package value
+
+import (
+	"reflect"
+
+	pref "github.com/golang/protobuf/v2/reflect/protoreflect"
+)
+
+func VectorOf(p interface{}, c Converter) pref.Vector {
+	// TODO: Validate that p is a *[]T?
+	rv := reflect.ValueOf(p).Elem()
+	return vectorReflect{rv, c}
+}
+
+type vectorReflect struct {
+	v    reflect.Value // addressable []T
+	conv Converter
+}
+
+func (vs vectorReflect) Len() int {
+	return vs.v.Len()
+}
+func (vs vectorReflect) Get(i int) pref.Value {
+	return vs.conv.PBValueOf(vs.v.Index(i))
+}
+func (vs vectorReflect) Set(i int, v pref.Value) {
+	vs.v.Index(i).Set(vs.conv.GoValueOf(v))
+}
+func (vs vectorReflect) Append(v pref.Value) {
+	vs.v.Set(reflect.Append(vs.v, vs.conv.GoValueOf(v)))
+}
+func (vs vectorReflect) Mutable(i int) pref.Mutable {
+	// Mutable is only valid for messages and panics for other kinds.
+	rv := vs.v.Index(i)
+	if rv.IsNil() {
+		// TODO: Is checking for nil proper behavior for custom messages?
+		pv := pref.ValueOf(vs.conv.NewMessage())
+		rv.Set(vs.conv.GoValueOf(pv))
+	}
+	return rv.Interface().(pref.Message)
+}
+func (vs vectorReflect) MutableAppend() pref.Mutable {
+	// MutableAppend is only valid for messages and panics for other kinds.
+	pv := pref.ValueOf(vs.conv.NewMessage())
+	vs.v.Set(reflect.Append(vs.v, vs.conv.GoValueOf(pv)))
+	return vs.v.Index(vs.Len() - 1).Interface().(pref.Message)
+}
+func (vs vectorReflect) Truncate(i int) {
+	vs.v.Set(vs.v.Slice(0, i))
+}
+func (vs vectorReflect) Unwrap() interface{} {
+	return vs.v.Interface()
+}
+func (vs vectorReflect) ProtoMutable() {}
+
+var (
+	_ pref.Vector = vectorReflect{}
+	_ Unwrapper   = vectorReflect{}
+)