reflect/prototype: initial commit
Add the prototype package which provides constructors for
protoreflect.{Enum,Message,Extension}Type.
Switch all usages of the internal/prototype equivalent to the new package.
Switch all custom implementions of {Enum,Message}Type to the new package.
Change-Id: Ia9dae6fed4f2b90e55c123627044a7faf098c4b1
Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/178438
Reviewed-by: Damien Neil <dneil@google.com>
diff --git a/internal/impl/export.go b/internal/impl/export.go
index 9ea3900..8c7c121 100644
--- a/internal/impl/export.go
+++ b/internal/impl/export.go
@@ -10,6 +10,7 @@
"google.golang.org/protobuf/encoding/prototext"
pref "google.golang.org/protobuf/reflect/protoreflect"
+ "google.golang.org/protobuf/reflect/prototype"
)
// Export is a zero-length named type that exists only to export a set of
@@ -31,24 +32,16 @@
// EnumTypeOf returns the protoreflect.EnumType for e.
func (Export) EnumTypeOf(e enum) pref.EnumType {
if ev, ok := e.(pref.Enum); ok {
- return &enumType{ev.Descriptor(), reflect.TypeOf(e)}
+ return &prototype.Enum{
+ EnumDescriptor: ev.Descriptor(),
+ NewEnum: func(n pref.EnumNumber) pref.Enum {
+ return reflect.ValueOf(n).Convert(reflect.TypeOf(e)).Interface().(pref.Enum)
+ },
+ }
}
return legacyWrapper.EnumTypeOf(e)
}
-// TODO: This needs to be centralized in a package.
-type enumType struct {
- // TODO: Remove me as an embedded field.
- pref.EnumDescriptor
- typ reflect.Type // must implement protoreflect.Enum
-}
-
-func (t *enumType) Descriptor() pref.EnumDescriptor { return t.EnumDescriptor }
-func (t *enumType) GoType() reflect.Type { return t.typ }
-func (t *enumType) New(n pref.EnumNumber) pref.Enum {
- return reflect.ValueOf(n).Convert(t.typ).Interface().(pref.Enum)
-}
-
// EnumDescriptorOf returns the protoreflect.EnumDescriptor for e.
func (Export) EnumDescriptorOf(e enum) pref.EnumDescriptor {
if ev, ok := e.(pref.Enum); ok {
@@ -82,24 +75,16 @@
// MessageTypeOf returns the protoreflect.MessageType for m.
func (Export) MessageTypeOf(m message) pref.MessageType {
if mv, ok := m.(pref.ProtoMessage); ok {
- return &messageType{mv.ProtoReflect().Descriptor(), reflect.TypeOf(m)}
+ return &prototype.Message{
+ MessageDescriptor: mv.ProtoReflect().Descriptor(),
+ NewMessage: func() pref.Message {
+ return reflect.New(reflect.TypeOf(m).Elem()).Interface().(pref.ProtoMessage).ProtoReflect()
+ },
+ }
}
return legacyWrapper.MessageTypeOf(m)
}
-// TODO: This needs to be centralized in a package.
-type messageType struct {
- // TODO: Remove me as an embedded field.
- pref.MessageDescriptor
- typ reflect.Type // must implement protoreflect.ProtoMessage
-}
-
-func (t *messageType) Descriptor() pref.MessageDescriptor { return t.MessageDescriptor }
-func (t *messageType) GoType() reflect.Type { return t.typ }
-func (t *messageType) New() pref.Message {
- return reflect.New(t.typ.Elem()).Interface().(pref.ProtoMessage).ProtoReflect()
-}
-
// MessageDescriptorOf returns the protoreflect.MessageDescriptor for m.
func (Export) MessageDescriptorOf(m message) pref.MessageDescriptor {
if mv, ok := m.(pref.ProtoMessage); ok {