internal/legacy: drop legacy prefix
The legacy prefix made sense when this functionality was part of impl.
Now that it is in its own package called legacy, the legacy prefix is silly.
Change-Id: I9e6ddb6185ce1f701e02768b505e6a05f3986f77
Reviewed-on: https://go-review.googlesource.com/c/152543
Reviewed-by: Herbie Ong <herbie@google.com>
diff --git a/internal/legacy/enum.go b/internal/legacy/enum.go
index 86cc7f2..1f5d391 100644
--- a/internal/legacy/enum.go
+++ b/internal/legacy/enum.go
@@ -16,18 +16,18 @@
ptype "github.com/golang/protobuf/v2/reflect/prototype"
)
-// legacyWrapEnum wraps v as a protoreflect.ProtoEnum,
+// wrapEnum wraps v as a protoreflect.ProtoEnum,
// where v must be a int32 kind and not implement the v2 API already.
-func legacyWrapEnum(v reflect.Value) pref.ProtoEnum {
- et := legacyLoadEnumType(v.Type())
+func wrapEnum(v reflect.Value) pref.ProtoEnum {
+ et := loadEnumType(v.Type())
return et.New(pref.EnumNumber(v.Int()))
}
var enumTypeCache sync.Map // map[reflect.Type]protoreflect.EnumType
-// legacyLoadEnumType dynamically loads a protoreflect.EnumType for t,
+// loadEnumType dynamically loads a protoreflect.EnumType for t,
// where t must be an int32 kind and not implement the v2 API already.
-func legacyLoadEnumType(t reflect.Type) pref.EnumType {
+func loadEnumType(t reflect.Type) pref.EnumType {
// Fast-path: check if a EnumType is cached for this concrete type.
if et, ok := enumTypeCache.Load(t); ok {
return et.(pref.EnumType)
@@ -35,12 +35,12 @@
// Slow-path: derive enum descriptor and initialize EnumType.
var m sync.Map // map[protoreflect.EnumNumber]proto.Enum
- ed := legacyLoadEnumDesc(t)
+ ed := loadEnumDesc(t)
et := ptype.GoEnum(ed, func(et pref.EnumType, n pref.EnumNumber) pref.ProtoEnum {
if e, ok := m.Load(n); ok {
return e.(pref.ProtoEnum)
}
- e := &legacyEnumWrapper{num: n, pbTyp: et, goTyp: t}
+ e := &enumWrapper{num: n, pbTyp: et, goTyp: t}
m.Store(n, e)
return e
})
@@ -48,40 +48,40 @@
return et.(pref.EnumType)
}
-type legacyEnumWrapper struct {
+type enumWrapper struct {
num pref.EnumNumber
pbTyp pref.EnumType
goTyp reflect.Type
}
-func (e *legacyEnumWrapper) Number() pref.EnumNumber {
+func (e *enumWrapper) Number() pref.EnumNumber {
return e.num
}
-func (e *legacyEnumWrapper) Type() pref.EnumType {
+func (e *enumWrapper) Type() pref.EnumType {
return e.pbTyp
}
-func (e *legacyEnumWrapper) ProtoReflect() pref.Enum {
+func (e *enumWrapper) ProtoReflect() pref.Enum {
return e
}
-func (e *legacyEnumWrapper) ProtoUnwrap() interface{} {
+func (e *enumWrapper) ProtoUnwrap() interface{} {
v := reflect.New(e.goTyp).Elem()
v.SetInt(int64(e.num))
return v.Interface()
}
var (
- _ pref.Enum = (*legacyEnumWrapper)(nil)
- _ pref.ProtoEnum = (*legacyEnumWrapper)(nil)
- _ pvalue.Unwrapper = (*legacyEnumWrapper)(nil)
+ _ pref.Enum = (*enumWrapper)(nil)
+ _ pref.ProtoEnum = (*enumWrapper)(nil)
+ _ pvalue.Unwrapper = (*enumWrapper)(nil)
)
var enumDescCache sync.Map // map[reflect.Type]protoreflect.EnumDescriptor
var enumNumberType = reflect.TypeOf(pref.EnumNumber(0))
-// legacyLoadEnumDesc returns an EnumDescriptor derived from the Go type,
+// loadEnumDesc returns an EnumDescriptor derived from the Go type,
// which must be an int32 kind and not implement the v2 API already.
-func legacyLoadEnumDesc(t reflect.Type) pref.EnumDescriptor {
+func loadEnumDesc(t reflect.Type) pref.EnumDescriptor {
// Fast-path: check if an EnumDescriptor is cached for this concrete type.
if v, ok := enumDescCache.Load(t); ok {
return v.(pref.EnumDescriptor)
@@ -101,9 +101,9 @@
if _, ok := ev.(pref.ProtoEnum); ok {
panic(fmt.Sprintf("%v already implements proto.Enum", t))
}
- if ed, ok := ev.(legacyEnum); ok {
+ if ed, ok := ev.(enumV1); ok {
b, idxs := ed.EnumDescriptor()
- fd := legacyLoadFileDesc(b)
+ fd := loadFileDesc(b)
// Derive syntax.
switch fd.GetSyntax() {
@@ -138,7 +138,7 @@
})
}
} else {
- // If the type does not implement legacyEnum, then there is no reliable
+ // If the type does not implement enumV1, then there is no reliable
// way to derive the original protobuf type information.
// We are unable to use the global enum registry since it is
// unfortunately keyed by the full name, which we do not know.
diff --git a/internal/legacy/export.go b/internal/legacy/export.go
index c8059a0..60dbd47 100644
--- a/internal/legacy/export.go
+++ b/internal/legacy/export.go
@@ -18,31 +18,31 @@
type Export struct{}
func (Export) EnumOf(e interface{}) pvalue.LegacyEnum {
- return legacyWrapEnum(reflect.ValueOf(e)).ProtoReflect().(pvalue.LegacyEnum)
+ return wrapEnum(reflect.ValueOf(e)).ProtoReflect().(pvalue.LegacyEnum)
}
func (Export) EnumTypeOf(e interface{}) pref.EnumType {
- return legacyLoadEnumType(reflect.TypeOf(e))
+ return loadEnumType(reflect.TypeOf(e))
}
func (Export) MessageOf(m interface{}) pvalue.LegacyMessage {
- return legacyWrapMessage(reflect.ValueOf(m)).ProtoReflect().(pvalue.LegacyMessage)
+ return wrapMessage(reflect.ValueOf(m)).ProtoReflect().(pvalue.LegacyMessage)
}
func (Export) MessageTypeOf(m interface{}) pref.MessageType {
- return legacyLoadMessageType(reflect.TypeOf(m)).Type
+ return loadMessageType(reflect.TypeOf(m)).Type
}
func (Export) ExtensionTypeOf(d pref.ExtensionDescriptor, t interface{}) pref.ExtensionType {
- return legacyExtensionTypeOf(d, reflect.TypeOf(t))
+ return extensionTypeOf(d, reflect.TypeOf(t))
}
func (Export) ExtensionDescFromType(t pref.ExtensionType) *protoV1.ExtensionDesc {
- return legacyExtensionDescFromType(t)
+ return extensionDescFromType(t)
}
func (Export) ExtensionTypeFromDesc(d *protoV1.ExtensionDesc) pref.ExtensionType {
- return legacyExtensionTypeFromDesc(d)
+ return extensionTypeFromDesc(d)
}
func init() {
diff --git a/internal/legacy/extension.go b/internal/legacy/extension.go
index 662e75c..1c76674 100644
--- a/internal/legacy/extension.go
+++ b/internal/legacy/extension.go
@@ -43,9 +43,9 @@
extensionDescCache sync.Map // map[protoreflect.ExtensionType]*protoapi.ExtensionDesc
)
-// legacyExtensionDescFromType converts a v2 protoreflect.ExtensionType to a
+// extensionDescFromType converts a v2 protoreflect.ExtensionType to a
// v1 protoapi.ExtensionDesc. The returned ExtensionDesc must not be mutated.
-func legacyExtensionDescFromType(t pref.ExtensionType) *papi.ExtensionDesc {
+func extensionDescFromType(t pref.ExtensionType) *papi.ExtensionDesc {
// Fast-path: check the cache for whether this ExtensionType has already
// been converted to a legacy descriptor.
if d, ok := extensionDescCache.Load(t); ok {
@@ -100,9 +100,9 @@
if fd := parentFileDescriptor(et); fd != nil {
protoPkg = string(fd.Package())
}
- if ed, ok := ev.(legacyEnum); ok && protoPkg == "" {
+ if ed, ok := ev.(enumV1); ok && protoPkg == "" {
b, _ := ed.EnumDescriptor()
- protoPkg = legacyLoadFileDesc(b).GetPackage()
+ protoPkg = loadFileDesc(b).GetPackage()
}
if protoPkg != "" {
@@ -130,14 +130,14 @@
return d
}
-// legacyExtensionTypeFromDesc converts a v1 protoapi.ExtensionDesc to a
+// extensionTypeFromDesc converts a v1 protoapi.ExtensionDesc to a
// v2 protoreflect.ExtensionType. The returned descriptor type takes ownership
// of the input extension desc. The input must not be mutated so long as the
// returned type is still in use.
-func legacyExtensionTypeFromDesc(d *papi.ExtensionDesc) pref.ExtensionType {
+func extensionTypeFromDesc(d *papi.ExtensionDesc) pref.ExtensionType {
// Fast-path: check whether an extension type is already nested within.
if d.Type != nil {
- // Cache descriptor for future legacyExtensionDescFromType operation.
+ // Cache descriptor for future extensionDescFromType operation.
// This assumes that there is only one legacy protoapi.ExtensionDesc
// that wraps any given specific protoreflect.ExtensionType.
extensionDescCache.LoadOrStore(d.Type, d)
@@ -184,18 +184,18 @@
return xt
}
-// legacyExtensionTypeOf returns a protoreflect.ExtensionType where the GoType
+// extensionTypeOf returns a protoreflect.ExtensionType where the GoType
// is the underlying v1 Go type instead of the wrapper types used to present
// v1 Go types as if they satisfied the v2 API.
//
// This function is only valid if xd.Kind is an enum or message.
-func legacyExtensionTypeOf(xd pref.ExtensionDescriptor, t reflect.Type) pref.ExtensionType {
+func extensionTypeOf(xd pref.ExtensionDescriptor, t reflect.Type) pref.ExtensionType {
// Step 1: Create an ExtensionType where GoType is the wrapper type.
conv := pvalue.NewLegacyConverter(t, xd.Kind(), Export{})
xt := ptype.GoExtension(xd, conv.EnumType, conv.MessageType)
// Step 2: Wrap ExtensionType such that GoType presents the legacy Go type.
- xt2 := &legacyExtensionType{ExtensionType: xt}
+ xt2 := &extensionType{ExtensionType: xt}
if xd.Cardinality() != pref.Repeated {
xt2.typ = t
xt2.new = func() interface{} {
@@ -236,7 +236,7 @@
return xt2
}
-type legacyExtensionType struct {
+type extensionType struct {
pref.ExtensionType
typ reflect.Type
new func() interface{}
@@ -244,9 +244,9 @@
interfaceOf func(pref.Value) interface{}
}
-func (x *legacyExtensionType) GoType() reflect.Type { return x.typ }
-func (x *legacyExtensionType) New() interface{} { return x.new() }
-func (x *legacyExtensionType) ValueOf(v interface{}) pref.Value { return x.valueOf(v) }
-func (x *legacyExtensionType) InterfaceOf(v pref.Value) interface{} { return x.interfaceOf(v) }
+func (x *extensionType) GoType() reflect.Type { return x.typ }
+func (x *extensionType) New() interface{} { return x.new() }
+func (x *extensionType) ValueOf(v interface{}) pref.Value { return x.valueOf(v) }
+func (x *extensionType) InterfaceOf(v pref.Value) interface{} { return x.interfaceOf(v) }
// TODO: Provide custom stringer with the new GoType.
diff --git a/internal/legacy/file.go b/internal/legacy/file.go
index 48b4d1c..5f09273 100644
--- a/internal/legacy/file.go
+++ b/internal/legacy/file.go
@@ -27,23 +27,23 @@
// compressed using GZIP. The []int is the path from the top-level file
// to the specific message or enum declaration.
type (
- legacyEnum interface {
+ enumV1 interface {
EnumDescriptor() ([]byte, []int)
}
- legacyMessage interface {
+ messageV1 interface {
Descriptor() ([]byte, []int)
}
)
var fileDescCache sync.Map // map[*byte]*descriptorV1.FileDescriptorProto
-// legacyLoadFileDesc unmarshals b as a compressed FileDescriptorProto message.
+// loadFileDesc unmarshals b as a compressed FileDescriptorProto message.
//
// This assumes that b is immutable and that b does not refer to part of a
// concatenated series of GZIP files (which would require shenanigans that
// rely on the concatenation properties of both protobufs and GZIP).
// File descriptors generated by protoc-gen-go do not rely on that property.
-func legacyLoadFileDesc(b []byte) *descriptorV1.FileDescriptorProto {
+func loadFileDesc(b []byte) *descriptorV1.FileDescriptorProto {
// Fast-path: check whether we already have a cached file descriptor.
if v, ok := fileDescCache.Load(&b[0]); ok {
return v.(*descriptorV1.FileDescriptorProto)
diff --git a/internal/legacy/file_test.go b/internal/legacy/file_test.go
index 6d994ac..35d9f9c 100644
--- a/internal/legacy/file_test.go
+++ b/internal/legacy/file_test.go
@@ -28,7 +28,7 @@
)
func mustLoadFileDesc(b []byte, _ []int) pref.FileDescriptor {
- fd, err := ptype.NewFileFromDescriptorProto(legacyLoadFileDesc(b), nil)
+ fd, err := ptype.NewFileFromDescriptorProto(loadFileDesc(b), nil)
if err != nil {
panic(err)
}
@@ -40,343 +40,343 @@
fileDescP2_20160225 := mustLoadFileDesc(new(proto2_20160225.Message).Descriptor())
tests = append(tests, []struct{ got, want pref.Descriptor }{{
- got: legacyLoadEnumDesc(reflect.TypeOf(proto2_20160225.SiblingEnum(0))),
+ got: loadEnumDesc(reflect.TypeOf(proto2_20160225.SiblingEnum(0))),
want: fileDescP2_20160225.Enums().ByName("SiblingEnum"),
}, {
- got: legacyLoadEnumDesc(reflect.TypeOf(proto2_20160225.Message_ChildEnum(0))),
+ got: loadEnumDesc(reflect.TypeOf(proto2_20160225.Message_ChildEnum(0))),
want: fileDescP2_20160225.Messages().ByName("Message").Enums().ByName("ChildEnum"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160225.SiblingMessage))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto2_20160225.SiblingMessage))),
want: fileDescP2_20160225.Messages().ByName("SiblingMessage"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160225.Message_ChildMessage))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto2_20160225.Message_ChildMessage))),
want: fileDescP2_20160225.Messages().ByName("Message").Messages().ByName("ChildMessage"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160225.Message))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto2_20160225.Message))),
want: fileDescP2_20160225.Messages().ByName("Message"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160225.Message_NamedGroup))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto2_20160225.Message_NamedGroup))),
want: fileDescP2_20160225.Messages().ByName("Message").Messages().ByName("NamedGroup"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160225.Message_OptionalGroup))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto2_20160225.Message_OptionalGroup))),
want: fileDescP2_20160225.Messages().ByName("Message").Messages().ByName("OptionalGroup"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160225.Message_RequiredGroup))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto2_20160225.Message_RequiredGroup))),
want: fileDescP2_20160225.Messages().ByName("Message").Messages().ByName("RequiredGroup"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160225.Message_RepeatedGroup))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto2_20160225.Message_RepeatedGroup))),
want: fileDescP2_20160225.Messages().ByName("Message").Messages().ByName("RepeatedGroup"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160225.Message_OneofGroup))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto2_20160225.Message_OneofGroup))),
want: fileDescP2_20160225.Messages().ByName("Message").Messages().ByName("OneofGroup"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160225.Message_ExtensionOptionalGroup))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto2_20160225.Message_ExtensionOptionalGroup))),
want: fileDescP2_20160225.Messages().ByName("Message").Messages().ByName("ExtensionOptionalGroup"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160225.Message_ExtensionRepeatedGroup))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto2_20160225.Message_ExtensionRepeatedGroup))),
want: fileDescP2_20160225.Messages().ByName("Message").Messages().ByName("ExtensionRepeatedGroup"),
}}...)
fileDescP3_20160225 := mustLoadFileDesc(new(proto3_20160225.Message).Descriptor())
tests = append(tests, []struct{ got, want pref.Descriptor }{{
- got: legacyLoadEnumDesc(reflect.TypeOf(proto3_20160225.SiblingEnum(0))),
+ got: loadEnumDesc(reflect.TypeOf(proto3_20160225.SiblingEnum(0))),
want: fileDescP3_20160225.Enums().ByName("SiblingEnum"),
}, {
- got: legacyLoadEnumDesc(reflect.TypeOf(proto3_20160225.Message_ChildEnum(0))),
+ got: loadEnumDesc(reflect.TypeOf(proto3_20160225.Message_ChildEnum(0))),
want: fileDescP3_20160225.Messages().ByName("Message").Enums().ByName("ChildEnum"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20160225.SiblingMessage))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto3_20160225.SiblingMessage))),
want: fileDescP3_20160225.Messages().ByName("SiblingMessage"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20160225.Message_ChildMessage))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto3_20160225.Message_ChildMessage))),
want: fileDescP3_20160225.Messages().ByName("Message").Messages().ByName("ChildMessage"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20160225.Message))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto3_20160225.Message))),
want: fileDescP3_20160225.Messages().ByName("Message"),
}}...)
fileDescP2_20160519 := mustLoadFileDesc(new(proto2_20160519.Message).Descriptor())
tests = append(tests, []struct{ got, want pref.Descriptor }{{
- got: legacyLoadEnumDesc(reflect.TypeOf(proto2_20160519.SiblingEnum(0))),
+ got: loadEnumDesc(reflect.TypeOf(proto2_20160519.SiblingEnum(0))),
want: fileDescP2_20160519.Enums().ByName("SiblingEnum"),
}, {
- got: legacyLoadEnumDesc(reflect.TypeOf(proto2_20160519.Message_ChildEnum(0))),
+ got: loadEnumDesc(reflect.TypeOf(proto2_20160519.Message_ChildEnum(0))),
want: fileDescP2_20160519.Messages().ByName("Message").Enums().ByName("ChildEnum"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160519.SiblingMessage))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto2_20160519.SiblingMessage))),
want: fileDescP2_20160519.Messages().ByName("SiblingMessage"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160519.Message_ChildMessage))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto2_20160519.Message_ChildMessage))),
want: fileDescP2_20160519.Messages().ByName("Message").Messages().ByName("ChildMessage"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160519.Message))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto2_20160519.Message))),
want: fileDescP2_20160519.Messages().ByName("Message"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160519.Message_NamedGroup))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto2_20160519.Message_NamedGroup))),
want: fileDescP2_20160519.Messages().ByName("Message").Messages().ByName("NamedGroup"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160519.Message_OptionalGroup))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto2_20160519.Message_OptionalGroup))),
want: fileDescP2_20160519.Messages().ByName("Message").Messages().ByName("OptionalGroup"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160519.Message_RequiredGroup))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto2_20160519.Message_RequiredGroup))),
want: fileDescP2_20160519.Messages().ByName("Message").Messages().ByName("RequiredGroup"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160519.Message_RepeatedGroup))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto2_20160519.Message_RepeatedGroup))),
want: fileDescP2_20160519.Messages().ByName("Message").Messages().ByName("RepeatedGroup"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160519.Message_OneofGroup))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto2_20160519.Message_OneofGroup))),
want: fileDescP2_20160519.Messages().ByName("Message").Messages().ByName("OneofGroup"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160519.Message_ExtensionOptionalGroup))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto2_20160519.Message_ExtensionOptionalGroup))),
want: fileDescP2_20160519.Messages().ByName("Message").Messages().ByName("ExtensionOptionalGroup"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160519.Message_ExtensionRepeatedGroup))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto2_20160519.Message_ExtensionRepeatedGroup))),
want: fileDescP2_20160519.Messages().ByName("Message").Messages().ByName("ExtensionRepeatedGroup"),
}}...)
fileDescP3_20160519 := mustLoadFileDesc(new(proto3_20160519.Message).Descriptor())
tests = append(tests, []struct{ got, want pref.Descriptor }{{
- got: legacyLoadEnumDesc(reflect.TypeOf(proto3_20160519.SiblingEnum(0))),
+ got: loadEnumDesc(reflect.TypeOf(proto3_20160519.SiblingEnum(0))),
want: fileDescP3_20160519.Enums().ByName("SiblingEnum"),
}, {
- got: legacyLoadEnumDesc(reflect.TypeOf(proto3_20160519.Message_ChildEnum(0))),
+ got: loadEnumDesc(reflect.TypeOf(proto3_20160519.Message_ChildEnum(0))),
want: fileDescP3_20160519.Messages().ByName("Message").Enums().ByName("ChildEnum"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20160519.SiblingMessage))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto3_20160519.SiblingMessage))),
want: fileDescP3_20160519.Messages().ByName("SiblingMessage"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20160519.Message_ChildMessage))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto3_20160519.Message_ChildMessage))),
want: fileDescP3_20160519.Messages().ByName("Message").Messages().ByName("ChildMessage"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20160519.Message))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto3_20160519.Message))),
want: fileDescP3_20160519.Messages().ByName("Message"),
}}...)
fileDescP2_20180125 := mustLoadFileDesc(new(proto2_20180125.Message).Descriptor())
tests = append(tests, []struct{ got, want pref.Descriptor }{{
- got: legacyLoadEnumDesc(reflect.TypeOf(proto2_20180125.SiblingEnum(0))),
+ got: loadEnumDesc(reflect.TypeOf(proto2_20180125.SiblingEnum(0))),
want: fileDescP2_20180125.Enums().ByName("SiblingEnum"),
}, {
- got: legacyLoadEnumDesc(reflect.TypeOf(proto2_20180125.Message_ChildEnum(0))),
+ got: loadEnumDesc(reflect.TypeOf(proto2_20180125.Message_ChildEnum(0))),
want: fileDescP2_20180125.Messages().ByName("Message").Enums().ByName("ChildEnum"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180125.SiblingMessage))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto2_20180125.SiblingMessage))),
want: fileDescP2_20180125.Messages().ByName("SiblingMessage"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180125.Message_ChildMessage))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto2_20180125.Message_ChildMessage))),
want: fileDescP2_20180125.Messages().ByName("Message").Messages().ByName("ChildMessage"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180125.Message))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto2_20180125.Message))),
want: fileDescP2_20180125.Messages().ByName("Message"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180125.Message_NamedGroup))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto2_20180125.Message_NamedGroup))),
want: fileDescP2_20180125.Messages().ByName("Message").Messages().ByName("NamedGroup"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180125.Message_OptionalGroup))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto2_20180125.Message_OptionalGroup))),
want: fileDescP2_20180125.Messages().ByName("Message").Messages().ByName("OptionalGroup"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180125.Message_RequiredGroup))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto2_20180125.Message_RequiredGroup))),
want: fileDescP2_20180125.Messages().ByName("Message").Messages().ByName("RequiredGroup"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180125.Message_RepeatedGroup))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto2_20180125.Message_RepeatedGroup))),
want: fileDescP2_20180125.Messages().ByName("Message").Messages().ByName("RepeatedGroup"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180125.Message_OneofGroup))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto2_20180125.Message_OneofGroup))),
want: fileDescP2_20180125.Messages().ByName("Message").Messages().ByName("OneofGroup"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180125.Message_ExtensionOptionalGroup))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto2_20180125.Message_ExtensionOptionalGroup))),
want: fileDescP2_20180125.Messages().ByName("Message").Messages().ByName("ExtensionOptionalGroup"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180125.Message_ExtensionRepeatedGroup))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto2_20180125.Message_ExtensionRepeatedGroup))),
want: fileDescP2_20180125.Messages().ByName("Message").Messages().ByName("ExtensionRepeatedGroup"),
}}...)
fileDescP3_20180125 := mustLoadFileDesc(new(proto3_20180125.Message).Descriptor())
tests = append(tests, []struct{ got, want pref.Descriptor }{{
- got: legacyLoadEnumDesc(reflect.TypeOf(proto3_20180125.SiblingEnum(0))),
+ got: loadEnumDesc(reflect.TypeOf(proto3_20180125.SiblingEnum(0))),
want: fileDescP3_20180125.Enums().ByName("SiblingEnum"),
}, {
- got: legacyLoadEnumDesc(reflect.TypeOf(proto3_20180125.Message_ChildEnum(0))),
+ got: loadEnumDesc(reflect.TypeOf(proto3_20180125.Message_ChildEnum(0))),
want: fileDescP3_20180125.Messages().ByName("Message").Enums().ByName("ChildEnum"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20180125.SiblingMessage))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto3_20180125.SiblingMessage))),
want: fileDescP3_20180125.Messages().ByName("SiblingMessage"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20180125.Message_ChildMessage))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto3_20180125.Message_ChildMessage))),
want: fileDescP3_20180125.Messages().ByName("Message").Messages().ByName("ChildMessage"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20180125.Message))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto3_20180125.Message))),
want: fileDescP3_20180125.Messages().ByName("Message"),
}}...)
fileDescP2_20180430 := mustLoadFileDesc(new(proto2_20180430.Message).Descriptor())
tests = append(tests, []struct{ got, want pref.Descriptor }{{
- got: legacyLoadEnumDesc(reflect.TypeOf(proto2_20180430.SiblingEnum(0))),
+ got: loadEnumDesc(reflect.TypeOf(proto2_20180430.SiblingEnum(0))),
want: fileDescP2_20180430.Enums().ByName("SiblingEnum"),
}, {
- got: legacyLoadEnumDesc(reflect.TypeOf(proto2_20180430.Message_ChildEnum(0))),
+ got: loadEnumDesc(reflect.TypeOf(proto2_20180430.Message_ChildEnum(0))),
want: fileDescP2_20180430.Messages().ByName("Message").Enums().ByName("ChildEnum"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180430.SiblingMessage))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto2_20180430.SiblingMessage))),
want: fileDescP2_20180430.Messages().ByName("SiblingMessage"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180430.Message_ChildMessage))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto2_20180430.Message_ChildMessage))),
want: fileDescP2_20180430.Messages().ByName("Message").Messages().ByName("ChildMessage"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180430.Message))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto2_20180430.Message))),
want: fileDescP2_20180430.Messages().ByName("Message"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180430.Message_NamedGroup))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto2_20180430.Message_NamedGroup))),
want: fileDescP2_20180430.Messages().ByName("Message").Messages().ByName("NamedGroup"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180430.Message_OptionalGroup))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto2_20180430.Message_OptionalGroup))),
want: fileDescP2_20180430.Messages().ByName("Message").Messages().ByName("OptionalGroup"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180430.Message_RequiredGroup))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto2_20180430.Message_RequiredGroup))),
want: fileDescP2_20180430.Messages().ByName("Message").Messages().ByName("RequiredGroup"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180430.Message_RepeatedGroup))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto2_20180430.Message_RepeatedGroup))),
want: fileDescP2_20180430.Messages().ByName("Message").Messages().ByName("RepeatedGroup"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180430.Message_OneofGroup))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto2_20180430.Message_OneofGroup))),
want: fileDescP2_20180430.Messages().ByName("Message").Messages().ByName("OneofGroup"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180430.Message_ExtensionOptionalGroup))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto2_20180430.Message_ExtensionOptionalGroup))),
want: fileDescP2_20180430.Messages().ByName("Message").Messages().ByName("ExtensionOptionalGroup"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180430.Message_ExtensionRepeatedGroup))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto2_20180430.Message_ExtensionRepeatedGroup))),
want: fileDescP2_20180430.Messages().ByName("Message").Messages().ByName("ExtensionRepeatedGroup"),
}}...)
fileDescP3_20180430 := mustLoadFileDesc(new(proto3_20180430.Message).Descriptor())
tests = append(tests, []struct{ got, want pref.Descriptor }{{
- got: legacyLoadEnumDesc(reflect.TypeOf(proto3_20180430.SiblingEnum(0))),
+ got: loadEnumDesc(reflect.TypeOf(proto3_20180430.SiblingEnum(0))),
want: fileDescP3_20180430.Enums().ByName("SiblingEnum"),
}, {
- got: legacyLoadEnumDesc(reflect.TypeOf(proto3_20180430.Message_ChildEnum(0))),
+ got: loadEnumDesc(reflect.TypeOf(proto3_20180430.Message_ChildEnum(0))),
want: fileDescP3_20180430.Messages().ByName("Message").Enums().ByName("ChildEnum"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20180430.SiblingMessage))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto3_20180430.SiblingMessage))),
want: fileDescP3_20180430.Messages().ByName("SiblingMessage"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20180430.Message_ChildMessage))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto3_20180430.Message_ChildMessage))),
want: fileDescP3_20180430.Messages().ByName("Message").Messages().ByName("ChildMessage"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20180430.Message))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto3_20180430.Message))),
want: fileDescP3_20180430.Messages().ByName("Message"),
}}...)
fileDescP2_20180814 := mustLoadFileDesc(new(proto2_20180814.Message).Descriptor())
tests = append(tests, []struct{ got, want pref.Descriptor }{{
- got: legacyLoadEnumDesc(reflect.TypeOf(proto2_20180814.SiblingEnum(0))),
+ got: loadEnumDesc(reflect.TypeOf(proto2_20180814.SiblingEnum(0))),
want: fileDescP2_20180814.Enums().ByName("SiblingEnum"),
}, {
- got: legacyLoadEnumDesc(reflect.TypeOf(proto2_20180814.Message_ChildEnum(0))),
+ got: loadEnumDesc(reflect.TypeOf(proto2_20180814.Message_ChildEnum(0))),
want: fileDescP2_20180814.Messages().ByName("Message").Enums().ByName("ChildEnum"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180814.SiblingMessage))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto2_20180814.SiblingMessage))),
want: fileDescP2_20180814.Messages().ByName("SiblingMessage"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180814.Message_ChildMessage))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto2_20180814.Message_ChildMessage))),
want: fileDescP2_20180814.Messages().ByName("Message").Messages().ByName("ChildMessage"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180814.Message))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto2_20180814.Message))),
want: fileDescP2_20180814.Messages().ByName("Message"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180814.Message_NamedGroup))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto2_20180814.Message_NamedGroup))),
want: fileDescP2_20180814.Messages().ByName("Message").Messages().ByName("NamedGroup"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180814.Message_OptionalGroup))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto2_20180814.Message_OptionalGroup))),
want: fileDescP2_20180814.Messages().ByName("Message").Messages().ByName("OptionalGroup"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180814.Message_RequiredGroup))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto2_20180814.Message_RequiredGroup))),
want: fileDescP2_20180814.Messages().ByName("Message").Messages().ByName("RequiredGroup"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180814.Message_RepeatedGroup))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto2_20180814.Message_RepeatedGroup))),
want: fileDescP2_20180814.Messages().ByName("Message").Messages().ByName("RepeatedGroup"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180814.Message_OneofGroup))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto2_20180814.Message_OneofGroup))),
want: fileDescP2_20180814.Messages().ByName("Message").Messages().ByName("OneofGroup"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180814.Message_ExtensionOptionalGroup))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto2_20180814.Message_ExtensionOptionalGroup))),
want: fileDescP2_20180814.Messages().ByName("Message").Messages().ByName("ExtensionOptionalGroup"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180814.Message_ExtensionRepeatedGroup))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto2_20180814.Message_ExtensionRepeatedGroup))),
want: fileDescP2_20180814.Messages().ByName("Message").Messages().ByName("ExtensionRepeatedGroup"),
}}...)
fileDescP3_20180814 := mustLoadFileDesc(new(proto3_20180814.Message).Descriptor())
tests = append(tests, []struct{ got, want pref.Descriptor }{{
- got: legacyLoadEnumDesc(reflect.TypeOf(proto3_20180814.SiblingEnum(0))),
+ got: loadEnumDesc(reflect.TypeOf(proto3_20180814.SiblingEnum(0))),
want: fileDescP3_20180814.Enums().ByName("SiblingEnum"),
}, {
- got: legacyLoadEnumDesc(reflect.TypeOf(proto3_20180814.Message_ChildEnum(0))),
+ got: loadEnumDesc(reflect.TypeOf(proto3_20180814.Message_ChildEnum(0))),
want: fileDescP3_20180814.Messages().ByName("Message").Enums().ByName("ChildEnum"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20180814.SiblingMessage))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto3_20180814.SiblingMessage))),
want: fileDescP3_20180814.Messages().ByName("SiblingMessage"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20180814.Message_ChildMessage))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto3_20180814.Message_ChildMessage))),
want: fileDescP3_20180814.Messages().ByName("Message").Messages().ByName("ChildMessage"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20180814.Message))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto3_20180814.Message))),
want: fileDescP3_20180814.Messages().ByName("Message"),
}}...)
fileDescP2_20181126 := mustLoadFileDesc(new(proto2_20181126.Message).Descriptor())
tests = append(tests, []struct{ got, want pref.Descriptor }{{
- got: legacyLoadEnumDesc(reflect.TypeOf(proto2_20181126.SiblingEnum(0))),
+ got: loadEnumDesc(reflect.TypeOf(proto2_20181126.SiblingEnum(0))),
want: fileDescP2_20181126.Enums().ByName("SiblingEnum"),
}, {
- got: legacyLoadEnumDesc(reflect.TypeOf(proto2_20181126.Message_ChildEnum(0))),
+ got: loadEnumDesc(reflect.TypeOf(proto2_20181126.Message_ChildEnum(0))),
want: fileDescP2_20181126.Messages().ByName("Message").Enums().ByName("ChildEnum"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20181126.SiblingMessage))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto2_20181126.SiblingMessage))),
want: fileDescP2_20181126.Messages().ByName("SiblingMessage"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20181126.Message_ChildMessage))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto2_20181126.Message_ChildMessage))),
want: fileDescP2_20181126.Messages().ByName("Message").Messages().ByName("ChildMessage"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20181126.Message))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto2_20181126.Message))),
want: fileDescP2_20181126.Messages().ByName("Message"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20181126.Message_NamedGroup))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto2_20181126.Message_NamedGroup))),
want: fileDescP2_20181126.Messages().ByName("Message").Messages().ByName("NamedGroup"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20181126.Message_OptionalGroup))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto2_20181126.Message_OptionalGroup))),
want: fileDescP2_20181126.Messages().ByName("Message").Messages().ByName("OptionalGroup"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20181126.Message_RequiredGroup))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto2_20181126.Message_RequiredGroup))),
want: fileDescP2_20181126.Messages().ByName("Message").Messages().ByName("RequiredGroup"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20181126.Message_RepeatedGroup))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto2_20181126.Message_RepeatedGroup))),
want: fileDescP2_20181126.Messages().ByName("Message").Messages().ByName("RepeatedGroup"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20181126.Message_OneofGroup))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto2_20181126.Message_OneofGroup))),
want: fileDescP2_20181126.Messages().ByName("Message").Messages().ByName("OneofGroup"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20181126.Message_ExtensionOptionalGroup))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto2_20181126.Message_ExtensionOptionalGroup))),
want: fileDescP2_20181126.Messages().ByName("Message").Messages().ByName("ExtensionOptionalGroup"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20181126.Message_ExtensionRepeatedGroup))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto2_20181126.Message_ExtensionRepeatedGroup))),
want: fileDescP2_20181126.Messages().ByName("Message").Messages().ByName("ExtensionRepeatedGroup"),
}}...)
fileDescP3_20181126 := mustLoadFileDesc(new(proto3_20181126.Message).Descriptor())
tests = append(tests, []struct{ got, want pref.Descriptor }{{
- got: legacyLoadEnumDesc(reflect.TypeOf(proto3_20181126.SiblingEnum(0))),
+ got: loadEnumDesc(reflect.TypeOf(proto3_20181126.SiblingEnum(0))),
want: fileDescP3_20181126.Enums().ByName("SiblingEnum"),
}, {
- got: legacyLoadEnumDesc(reflect.TypeOf(proto3_20181126.Message_ChildEnum(0))),
+ got: loadEnumDesc(reflect.TypeOf(proto3_20181126.Message_ChildEnum(0))),
want: fileDescP3_20181126.Messages().ByName("Message").Enums().ByName("ChildEnum"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20181126.SiblingMessage))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto3_20181126.SiblingMessage))),
want: fileDescP3_20181126.Messages().ByName("SiblingMessage"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20181126.Message_ChildMessage))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto3_20181126.Message_ChildMessage))),
want: fileDescP3_20181126.Messages().ByName("Message").Messages().ByName("ChildMessage"),
}, {
- got: legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20181126.Message))),
+ got: loadMessageDesc(reflect.TypeOf(new(proto3_20181126.Message))),
want: fileDescP3_20181126.Messages().ByName("Message"),
}}...)
diff --git a/internal/legacy/message.go b/internal/legacy/message.go
index a81bb2e..83e723e 100644
--- a/internal/legacy/message.go
+++ b/internal/legacy/message.go
@@ -19,25 +19,25 @@
ptype "github.com/golang/protobuf/v2/reflect/prototype"
)
-// legacyWrapMessage wraps v as a protoreflect.ProtoMessage,
+// wrapMessage wraps v as a protoreflect.ProtoMessage,
// where v must be a *struct kind and not implement the v2 API already.
-func legacyWrapMessage(v reflect.Value) pref.ProtoMessage {
- mt := legacyLoadMessageType(v.Type())
+func wrapMessage(v reflect.Value) pref.ProtoMessage {
+ mt := loadMessageType(v.Type())
return mt.MessageOf(v.Interface()).Interface()
}
var messageTypeCache sync.Map // map[reflect.Type]*MessageType
-// legacyLoadMessageType dynamically loads a *MessageType for t,
+// loadMessageType dynamically loads a *MessageType for t,
// where t must be a *struct kind and not implement the v2 API already.
-func legacyLoadMessageType(t reflect.Type) *pimpl.MessageType {
+func loadMessageType(t reflect.Type) *pimpl.MessageType {
// Fast-path: check if a MessageType is cached for this concrete type.
if mt, ok := messageTypeCache.Load(t); ok {
return mt.(*pimpl.MessageType)
}
// Slow-path: derive message descriptor and initialize MessageType.
- md := legacyLoadMessageDesc(t)
+ md := loadMessageDesc(t)
mt := new(pimpl.MessageType)
mt.Type = ptype.GoMessage(md, func(pref.MessageType) pref.ProtoMessage {
p := reflect.New(t.Elem()).Interface()
@@ -49,9 +49,9 @@
var messageDescCache sync.Map // map[reflect.Type]protoreflect.MessageDescriptor
-// legacyLoadMessageDesc returns an MessageDescriptor derived from the Go type,
+// loadMessageDesc returns an MessageDescriptor derived from the Go type,
// which must be a *struct kind and not implement the v2 API already.
-func legacyLoadMessageDesc(t reflect.Type) pref.MessageDescriptor {
+func loadMessageDesc(t reflect.Type) pref.MessageDescriptor {
return messageDescSet{}.Load(t)
}
@@ -108,9 +108,9 @@
if _, ok := mv.(pref.ProtoMessage); ok {
panic(fmt.Sprintf("%v already implements proto.Message", t))
}
- if md, ok := mv.(legacyMessage); ok {
+ if md, ok := mv.(messageV1); ok {
b, idxs := md.Descriptor()
- fd := legacyLoadFileDesc(b)
+ fd := loadFileDesc(b)
// Derive syntax.
switch fd.GetSyntax() {
@@ -128,7 +128,7 @@
m.FullName = m.FullName.Append(pref.Name(md.GetName()))
}
} else {
- // If the type does not implement legacyMessage, then the only way to
+ // If the type does not implement messageV1, then the only way to
// obtain the full name is through the registry. However, this is
// unreliable as some generated messages register with a fork of
// golang/protobuf, so the registry may not have this information.
@@ -221,7 +221,7 @@
if ev, ok := reflect.Zero(t).Interface().(pref.ProtoEnum); ok {
f.EnumType = ev.ProtoReflect().Type()
} else {
- f.EnumType = legacyLoadEnumDesc(t)
+ f.EnumType = loadEnumDesc(t)
}
}
if f.MessageType == nil && (f.Kind == pref.MessageKind || f.Kind == pref.GroupKind) {
