internal/legacy: extract legacy support out from the impl package
The impl package currently supports wrapping legacy v1 enums and messages
so that they implement the v2 reflective APIs. This functionality is necessary
for v1 and v2 to interoperate. However, the existence of this functionality
presents several problems:
* A significant portion of the complexity in impl is for legacy wrapping.
* This complexity is linked into a Go binary even if all the other messages
in the binary natively support v2 reflection.
* It presents a cyclic dependency when trying to generate descriptor proto.
Suppose you are generating descriptor.proto. The generated code would want to
depend on the impl package because impl is the runtime implementation for
protobuf messages. However, impl currently depends depends on descriptor in
order to wrap legacy enum and messages since it needs the ability to dynamically
create new protobuf descriptor types. In the case of descriptor.proto, it would
presumably be generated with native reflection support, so the legacy wrapping
logic is unneccessary.
To break the dependency of impl on descriptor, we move the legacy support logic
to a different package and instead add hooks in impl so that legacy support could
be dynamically registered at runtime. This is dependency injection.
Change-Id: I01a582908ed5629993f6699e9bf2f4bee93857a4
Reviewed-on: https://go-review.googlesource.com/c/151877
Reviewed-by: Herbie Ong <herbie@google.com>
diff --git a/internal/legacy/enum.go b/internal/legacy/enum.go
new file mode 100644
index 0000000..86cc7f2
--- /dev/null
+++ b/internal/legacy/enum.go
@@ -0,0 +1,162 @@
+// 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 legacy
+
+import (
+ "fmt"
+ "math"
+ "reflect"
+ "sync"
+
+ descriptorV1 "github.com/golang/protobuf/protoc-gen-go/descriptor"
+ pvalue "github.com/golang/protobuf/v2/internal/value"
+ pref "github.com/golang/protobuf/v2/reflect/protoreflect"
+ ptype "github.com/golang/protobuf/v2/reflect/prototype"
+)
+
+// legacyWrapEnum 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())
+ return et.New(pref.EnumNumber(v.Int()))
+}
+
+var enumTypeCache sync.Map // map[reflect.Type]protoreflect.EnumType
+
+// legacyLoadEnumType 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 {
+ // Fast-path: check if a EnumType is cached for this concrete type.
+ if et, ok := enumTypeCache.Load(t); ok {
+ return et.(pref.EnumType)
+ }
+
+ // Slow-path: derive enum descriptor and initialize EnumType.
+ var m sync.Map // map[protoreflect.EnumNumber]proto.Enum
+ ed := legacyLoadEnumDesc(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}
+ m.Store(n, e)
+ return e
+ })
+ enumTypeCache.Store(t, et)
+ return et.(pref.EnumType)
+}
+
+type legacyEnumWrapper struct {
+ num pref.EnumNumber
+ pbTyp pref.EnumType
+ goTyp reflect.Type
+}
+
+func (e *legacyEnumWrapper) Number() pref.EnumNumber {
+ return e.num
+}
+func (e *legacyEnumWrapper) Type() pref.EnumType {
+ return e.pbTyp
+}
+func (e *legacyEnumWrapper) ProtoReflect() pref.Enum {
+ return e
+}
+func (e *legacyEnumWrapper) 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)
+)
+
+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,
+// which must be an int32 kind and not implement the v2 API already.
+func legacyLoadEnumDesc(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)
+ }
+
+ // Slow-path: initialize EnumDescriptor from the proto descriptor.
+ if t.Kind() != reflect.Int32 || t.PkgPath() == "" {
+ panic(fmt.Sprintf("got %v, want named int32 kind", t))
+ }
+ if t == enumNumberType {
+ panic(fmt.Sprintf("cannot be %v", t))
+ }
+
+ // Derive the enum descriptor from the raw descriptor proto.
+ e := new(ptype.StandaloneEnum)
+ ev := reflect.Zero(t).Interface()
+ if _, ok := ev.(pref.ProtoEnum); ok {
+ panic(fmt.Sprintf("%v already implements proto.Enum", t))
+ }
+ if ed, ok := ev.(legacyEnum); ok {
+ b, idxs := ed.EnumDescriptor()
+ fd := legacyLoadFileDesc(b)
+
+ // Derive syntax.
+ switch fd.GetSyntax() {
+ case "proto2", "":
+ e.Syntax = pref.Proto2
+ case "proto3":
+ e.Syntax = pref.Proto3
+ }
+
+ // Derive the full name and correct enum descriptor.
+ var ed *descriptorV1.EnumDescriptorProto
+ e.FullName = pref.FullName(fd.GetPackage())
+ if len(idxs) == 1 {
+ ed = fd.EnumType[idxs[0]]
+ e.FullName = e.FullName.Append(pref.Name(ed.GetName()))
+ } else {
+ md := fd.MessageType[idxs[0]]
+ e.FullName = e.FullName.Append(pref.Name(md.GetName()))
+ for _, i := range idxs[1 : len(idxs)-1] {
+ md = md.NestedType[i]
+ e.FullName = e.FullName.Append(pref.Name(md.GetName()))
+ }
+ ed = md.EnumType[idxs[len(idxs)-1]]
+ e.FullName = e.FullName.Append(pref.Name(ed.GetName()))
+ }
+
+ // Derive the enum values.
+ for _, vd := range ed.GetValue() {
+ e.Values = append(e.Values, ptype.EnumValue{
+ Name: pref.Name(vd.GetName()),
+ Number: pref.EnumNumber(vd.GetNumber()),
+ })
+ }
+ } else {
+ // If the type does not implement legacyEnum, 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.
+ // Furthermore, some generated enums register with a fork of
+ // golang/protobuf so the enum may not even be found in the registry.
+ //
+ // Instead, create a bogus enum descriptor to ensure that
+ // most operations continue to work. For example, textpb and jsonpb
+ // will be unable to parse a message with an enum value by name.
+ e.Syntax = pref.Proto2
+ e.FullName = deriveFullName(t)
+ e.Values = []ptype.EnumValue{{Name: "INVALID", Number: math.MinInt32}}
+ }
+
+ ed, err := ptype.NewEnum(e)
+ if err != nil {
+ panic(err)
+ }
+ enumDescCache.Store(t, ed)
+ return ed
+}
diff --git a/internal/legacy/export.go b/internal/legacy/export.go
new file mode 100644
index 0000000..c8059a0
--- /dev/null
+++ b/internal/legacy/export.go
@@ -0,0 +1,50 @@
+// 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 legacy
+
+import (
+ "reflect"
+
+ protoV1 "github.com/golang/protobuf/proto"
+ pimpl "github.com/golang/protobuf/v2/internal/impl"
+ pvalue "github.com/golang/protobuf/v2/internal/value"
+ pref "github.com/golang/protobuf/v2/reflect/protoreflect"
+)
+
+// Export is a zero-length named type that exists only to export a set of
+// functions that we do not want to appear in godoc.
+type Export struct{}
+
+func (Export) EnumOf(e interface{}) pvalue.LegacyEnum {
+ return legacyWrapEnum(reflect.ValueOf(e)).ProtoReflect().(pvalue.LegacyEnum)
+}
+
+func (Export) EnumTypeOf(e interface{}) pref.EnumType {
+ return legacyLoadEnumType(reflect.TypeOf(e))
+}
+
+func (Export) MessageOf(m interface{}) pvalue.LegacyMessage {
+ return legacyWrapMessage(reflect.ValueOf(m)).ProtoReflect().(pvalue.LegacyMessage)
+}
+
+func (Export) MessageTypeOf(m interface{}) pref.MessageType {
+ return legacyLoadMessageType(reflect.TypeOf(m)).Type
+}
+
+func (Export) ExtensionTypeOf(d pref.ExtensionDescriptor, t interface{}) pref.ExtensionType {
+ return legacyExtensionTypeOf(d, reflect.TypeOf(t))
+}
+
+func (Export) ExtensionDescFromType(t pref.ExtensionType) *protoV1.ExtensionDesc {
+ return legacyExtensionDescFromType(t)
+}
+
+func (Export) ExtensionTypeFromDesc(d *protoV1.ExtensionDesc) pref.ExtensionType {
+ return legacyExtensionTypeFromDesc(d)
+}
+
+func init() {
+ pimpl.RegisterLegacyWrapper(Export{})
+}
diff --git a/internal/legacy/extension.go b/internal/legacy/extension.go
new file mode 100644
index 0000000..700bc43
--- /dev/null
+++ b/internal/legacy/extension.go
@@ -0,0 +1,206 @@
+// 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 legacy
+
+import (
+ "fmt"
+ "reflect"
+
+ papi "github.com/golang/protobuf/protoapi"
+ ptag "github.com/golang/protobuf/v2/internal/encoding/tag"
+ pimpl "github.com/golang/protobuf/v2/internal/impl"
+ pvalue "github.com/golang/protobuf/v2/internal/value"
+ pref "github.com/golang/protobuf/v2/reflect/protoreflect"
+ ptype "github.com/golang/protobuf/v2/reflect/prototype"
+)
+
+func legacyExtensionDescFromType(t pref.ExtensionType) *papi.ExtensionDesc {
+ if t, ok := t.(dualExtensionType); ok {
+ return t.desc
+ }
+
+ // Determine the parent type if possible.
+ var parent papi.Message
+ if mt, ok := t.ExtendedType().(pref.MessageType); ok {
+ // Create a new parent message and unwrap it if possible.
+ mv := mt.New()
+ t := reflect.TypeOf(mv)
+ if mv, ok := mv.(pvalue.Unwrapper); ok {
+ t = reflect.TypeOf(mv.ProtoUnwrap())
+ }
+
+ // Check whether the message implements the legacy v1 Message interface.
+ mz := reflect.Zero(t).Interface()
+ if mz, ok := mz.(papi.Message); ok {
+ parent = mz
+ }
+ }
+
+ // Determine the v1 extension type, which is unfortunately not the same as
+ // the v2 ExtensionType.GoType.
+ extType := t.GoType()
+ switch extType.Kind() {
+ case reflect.Bool, reflect.Int32, reflect.Int64, reflect.Uint32, reflect.Uint64, reflect.Float32, reflect.Float64, reflect.String:
+ extType = reflect.PtrTo(extType) // T -> *T for singular scalar fields
+ case reflect.Ptr:
+ if extType.Elem().Kind() == reflect.Slice {
+ extType = extType.Elem() // *[]T -> []T for repeated fields
+ }
+ }
+
+ // Reconstruct the legacy enum full name, which is an odd mixture of the
+ // proto package name with the Go type name.
+ var enumName string
+ if t.Kind() == pref.EnumKind {
+ // Derive Go type name.
+ // For legacy enums, unwrap the wrapper to get the underlying Go type.
+ et := t.EnumType().(pref.EnumType)
+ var ev interface{} = et.New(0)
+ if u, ok := ev.(pvalue.Unwrapper); ok {
+ ev = u.ProtoUnwrap()
+ }
+ enumName = reflect.TypeOf(ev).Name()
+
+ // Derive the proto package name.
+ // For legacy enums, obtain the proto package from the raw descriptor.
+ var protoPkg string
+ if fd := parentFileDescriptor(et); fd != nil {
+ protoPkg = string(fd.Package())
+ }
+ if ed, ok := ev.(legacyEnum); ok && protoPkg == "" {
+ b, _ := ed.EnumDescriptor()
+ protoPkg = legacyLoadFileDesc(b).GetPackage()
+ }
+
+ if protoPkg != "" {
+ enumName = protoPkg + "." + enumName
+ }
+ }
+
+ // Derive the proto file that the extension was declared within.
+ var filename string
+ if fd := parentFileDescriptor(t); fd != nil {
+ filename = fd.Path()
+ }
+
+ // Construct and return a v1 ExtensionDesc.
+ return &papi.ExtensionDesc{
+ Type: t,
+ ExtendedType: parent,
+ ExtensionType: reflect.Zero(extType).Interface(),
+ Field: int32(t.Number()),
+ Name: string(t.FullName()),
+ Tag: ptag.Marshal(t, enumName),
+ Filename: filename,
+ }
+}
+
+func legacyExtensionTypeFromDesc(d *papi.ExtensionDesc) pref.ExtensionType {
+ if d.Type != nil {
+ return dualExtensionType{d.Type, d}
+ }
+
+ // Derive basic field information from the struct tag.
+ t := reflect.TypeOf(d.ExtensionType)
+ isOptional := t.Kind() == reflect.Ptr && t.Elem().Kind() != reflect.Struct
+ isRepeated := t.Kind() == reflect.Slice && t.Elem().Kind() != reflect.Uint8
+ if isOptional || isRepeated {
+ t = t.Elem()
+ }
+ f := ptag.Unmarshal(d.Tag, t)
+
+ // Construct a v2 ExtensionType.
+ conv := pvalue.NewLegacyConverter(t, f.Kind, Export{})
+ xd, err := ptype.NewExtension(&ptype.StandaloneExtension{
+ FullName: pref.FullName(d.Name),
+ Number: pref.FieldNumber(d.Field),
+ Cardinality: f.Cardinality,
+ Kind: f.Kind,
+ Default: f.Default,
+ Options: f.Options,
+ EnumType: conv.EnumType,
+ MessageType: conv.MessageType,
+ ExtendedType: Export{}.MessageTypeOf(d.ExtendedType),
+ })
+ if err != nil {
+ panic(err)
+ }
+ xt := pimpl.Export{}.ExtensionTypeOf(xd, reflect.Zero(t).Interface())
+ return dualExtensionType{xt, d}
+}
+
+type dualExtensionType struct {
+ pref.ExtensionType
+ desc *papi.ExtensionDesc
+}
+
+// TODO: Provide custom stringer for dualExtensionType.
+
+// legacyExtensionTypeOf 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 {
+ // 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}
+ if xd.Cardinality() != pref.Repeated {
+ xt2.typ = t
+ xt2.new = func() interface{} {
+ return xt.New().(pvalue.Unwrapper).ProtoUnwrap()
+ }
+ xt2.valueOf = func(v interface{}) pref.Value {
+ if reflect.TypeOf(v) != xt2.typ {
+ panic(fmt.Sprintf("invalid type: got %T, want %v", v, xt2.typ))
+ }
+ if xd.Kind() == pref.EnumKind {
+ return xt.ValueOf(Export{}.EnumOf(v))
+ } else {
+ return xt.ValueOf(Export{}.MessageOf(v))
+ }
+ }
+ xt2.interfaceOf = func(v pref.Value) interface{} {
+ return xt.InterfaceOf(v).(pvalue.Unwrapper).ProtoUnwrap()
+ }
+ } else {
+ xt2.typ = reflect.PtrTo(reflect.SliceOf(t))
+ xt2.new = func() interface{} {
+ return reflect.New(xt2.typ.Elem()).Interface()
+ }
+ xt2.valueOf = func(v interface{}) pref.Value {
+ if reflect.TypeOf(v) != xt2.typ {
+ panic(fmt.Sprintf("invalid type: got %T, want %v", v, xt2.typ))
+ }
+ return pref.ValueOf(pvalue.ListOf(v, conv))
+ }
+ xt2.interfaceOf = func(pv pref.Value) interface{} {
+ v := pv.List().(pvalue.Unwrapper).ProtoUnwrap()
+ if reflect.TypeOf(v) != xt2.typ {
+ panic(fmt.Sprintf("invalid type: got %T, want %v", v, xt2.typ))
+ }
+ return v
+ }
+ }
+ return xt2
+}
+
+type legacyExtensionType struct {
+ pref.ExtensionType
+ typ reflect.Type
+ new func() interface{}
+ valueOf func(interface{}) pref.Value
+ 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) }
+
+// TODO: Provide custom stringer with the new GoType.
diff --git a/internal/legacy/file.go b/internal/legacy/file.go
new file mode 100644
index 0000000..48b4d1c
--- /dev/null
+++ b/internal/legacy/file.go
@@ -0,0 +1,80 @@
+// 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 legacy
+
+import (
+ "bytes"
+ "compress/gzip"
+ "io/ioutil"
+ "sync"
+
+ // TODO: Avoid reliance on old API. However, there is currently a
+ // chicken and egg problem where we need the descriptor protos to implement
+ // the new API.
+ protoV1 "github.com/golang/protobuf/proto"
+ descriptorV1 "github.com/golang/protobuf/protoc-gen-go/descriptor"
+ pref "github.com/golang/protobuf/v2/reflect/protoreflect"
+)
+
+// Every enum and message type generated by protoc-gen-go since commit 2fc053c5
+// on February 25th, 2016 has had a method to get the raw descriptor.
+// Types that were not generated by protoc-gen-go or were generated prior
+// to that version are not supported.
+//
+// The []byte returned is the encoded form of a FileDescriptorProto message
+// compressed using GZIP. The []int is the path from the top-level file
+// to the specific message or enum declaration.
+type (
+ legacyEnum interface {
+ EnumDescriptor() ([]byte, []int)
+ }
+ legacyMessage interface {
+ Descriptor() ([]byte, []int)
+ }
+)
+
+var fileDescCache sync.Map // map[*byte]*descriptorV1.FileDescriptorProto
+
+// legacyLoadFileDesc 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 {
+ // Fast-path: check whether we already have a cached file descriptor.
+ if v, ok := fileDescCache.Load(&b[0]); ok {
+ return v.(*descriptorV1.FileDescriptorProto)
+ }
+
+ // Slow-path: decompress and unmarshal the file descriptor proto.
+ m := new(descriptorV1.FileDescriptorProto)
+ zr, err := gzip.NewReader(bytes.NewReader(b))
+ if err != nil {
+ panic(err)
+ }
+ b, err = ioutil.ReadAll(zr)
+ if err != nil {
+ panic(err)
+ }
+ // TODO: What about extensions?
+ // The protoV1 API does not eagerly unmarshal extensions.
+ if err := protoV1.Unmarshal(b, m); err != nil {
+ panic(err)
+ }
+ fileDescCache.Store(&b[0], m)
+ return m
+}
+
+// parentFileDescriptor returns the parent protoreflect.FileDescriptor for the
+// provide descriptor. It returns nil if there is no parent.
+func parentFileDescriptor(d pref.Descriptor) pref.FileDescriptor {
+ for ok := true; ok; d, ok = d.Parent() {
+ if fd, _ := d.(pref.FileDescriptor); fd != nil {
+ return fd
+ }
+ }
+ return nil
+}
diff --git a/internal/legacy/file_test.go b/internal/legacy/file_test.go
new file mode 100644
index 0000000..6d994ac
--- /dev/null
+++ b/internal/legacy/file_test.go
@@ -0,0 +1,440 @@
+// 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 legacy
+
+import (
+ "reflect"
+ "testing"
+
+ pragma "github.com/golang/protobuf/v2/internal/pragma"
+ pref "github.com/golang/protobuf/v2/reflect/protoreflect"
+ ptype "github.com/golang/protobuf/v2/reflect/prototype"
+ cmp "github.com/google/go-cmp/cmp"
+
+ proto2_20160225 "github.com/golang/protobuf/v2/internal/testprotos/legacy/proto2.v0.0.0-20160225-2fc053c5"
+ proto2_20160519 "github.com/golang/protobuf/v2/internal/testprotos/legacy/proto2.v0.0.0-20160519-a4ab9ec5"
+ proto2_20180125 "github.com/golang/protobuf/v2/internal/testprotos/legacy/proto2.v1.0.0-20180125-92554152"
+ proto2_20180430 "github.com/golang/protobuf/v2/internal/testprotos/legacy/proto2.v1.1.0-20180430-b4deda09"
+ proto2_20180814 "github.com/golang/protobuf/v2/internal/testprotos/legacy/proto2.v1.2.0-20180814-aa810b61"
+ proto2_20181126 "github.com/golang/protobuf/v2/internal/testprotos/legacy/proto2.v1.2.1-20181126-8d0c54c1"
+ proto3_20160225 "github.com/golang/protobuf/v2/internal/testprotos/legacy/proto3.v0.0.0-20160225-2fc053c5"
+ proto3_20160519 "github.com/golang/protobuf/v2/internal/testprotos/legacy/proto3.v0.0.0-20160519-a4ab9ec5"
+ proto3_20180125 "github.com/golang/protobuf/v2/internal/testprotos/legacy/proto3.v1.0.0-20180125-92554152"
+ proto3_20180430 "github.com/golang/protobuf/v2/internal/testprotos/legacy/proto3.v1.1.0-20180430-b4deda09"
+ proto3_20180814 "github.com/golang/protobuf/v2/internal/testprotos/legacy/proto3.v1.2.0-20180814-aa810b61"
+ proto3_20181126 "github.com/golang/protobuf/v2/internal/testprotos/legacy/proto3.v1.2.1-20181126-8d0c54c1"
+)
+
+func mustLoadFileDesc(b []byte, _ []int) pref.FileDescriptor {
+ fd, err := ptype.NewFileFromDescriptorProto(legacyLoadFileDesc(b), nil)
+ if err != nil {
+ panic(err)
+ }
+ return fd
+}
+
+func TestDescriptor(t *testing.T) {
+ var tests []struct{ got, want pref.Descriptor }
+
+ fileDescP2_20160225 := mustLoadFileDesc(new(proto2_20160225.Message).Descriptor())
+ tests = append(tests, []struct{ got, want pref.Descriptor }{{
+ got: legacyLoadEnumDesc(reflect.TypeOf(proto2_20160225.SiblingEnum(0))),
+ want: fileDescP2_20160225.Enums().ByName("SiblingEnum"),
+ }, {
+ got: legacyLoadEnumDesc(reflect.TypeOf(proto2_20160225.Message_ChildEnum(0))),
+ want: fileDescP2_20160225.Messages().ByName("Message").Enums().ByName("ChildEnum"),
+ }, {
+ got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160225.SiblingMessage))),
+ want: fileDescP2_20160225.Messages().ByName("SiblingMessage"),
+ }, {
+ got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160225.Message_ChildMessage))),
+ want: fileDescP2_20160225.Messages().ByName("Message").Messages().ByName("ChildMessage"),
+ }, {
+ got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160225.Message))),
+ want: fileDescP2_20160225.Messages().ByName("Message"),
+ }, {
+ got: legacyLoadMessageDesc(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))),
+ want: fileDescP2_20160225.Messages().ByName("Message").Messages().ByName("OptionalGroup"),
+ }, {
+ got: legacyLoadMessageDesc(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))),
+ want: fileDescP2_20160225.Messages().ByName("Message").Messages().ByName("RepeatedGroup"),
+ }, {
+ got: legacyLoadMessageDesc(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))),
+ want: fileDescP2_20160225.Messages().ByName("Message").Messages().ByName("ExtensionOptionalGroup"),
+ }, {
+ got: legacyLoadMessageDesc(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))),
+ want: fileDescP3_20160225.Enums().ByName("SiblingEnum"),
+ }, {
+ got: legacyLoadEnumDesc(reflect.TypeOf(proto3_20160225.Message_ChildEnum(0))),
+ want: fileDescP3_20160225.Messages().ByName("Message").Enums().ByName("ChildEnum"),
+ }, {
+ got: legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20160225.SiblingMessage))),
+ want: fileDescP3_20160225.Messages().ByName("SiblingMessage"),
+ }, {
+ got: legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20160225.Message_ChildMessage))),
+ want: fileDescP3_20160225.Messages().ByName("Message").Messages().ByName("ChildMessage"),
+ }, {
+ got: legacyLoadMessageDesc(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))),
+ want: fileDescP2_20160519.Enums().ByName("SiblingEnum"),
+ }, {
+ got: legacyLoadEnumDesc(reflect.TypeOf(proto2_20160519.Message_ChildEnum(0))),
+ want: fileDescP2_20160519.Messages().ByName("Message").Enums().ByName("ChildEnum"),
+ }, {
+ got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160519.SiblingMessage))),
+ want: fileDescP2_20160519.Messages().ByName("SiblingMessage"),
+ }, {
+ got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160519.Message_ChildMessage))),
+ want: fileDescP2_20160519.Messages().ByName("Message").Messages().ByName("ChildMessage"),
+ }, {
+ got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20160519.Message))),
+ want: fileDescP2_20160519.Messages().ByName("Message"),
+ }, {
+ got: legacyLoadMessageDesc(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))),
+ want: fileDescP2_20160519.Messages().ByName("Message").Messages().ByName("OptionalGroup"),
+ }, {
+ got: legacyLoadMessageDesc(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))),
+ want: fileDescP2_20160519.Messages().ByName("Message").Messages().ByName("RepeatedGroup"),
+ }, {
+ got: legacyLoadMessageDesc(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))),
+ want: fileDescP2_20160519.Messages().ByName("Message").Messages().ByName("ExtensionOptionalGroup"),
+ }, {
+ got: legacyLoadMessageDesc(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))),
+ want: fileDescP3_20160519.Enums().ByName("SiblingEnum"),
+ }, {
+ got: legacyLoadEnumDesc(reflect.TypeOf(proto3_20160519.Message_ChildEnum(0))),
+ want: fileDescP3_20160519.Messages().ByName("Message").Enums().ByName("ChildEnum"),
+ }, {
+ got: legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20160519.SiblingMessage))),
+ want: fileDescP3_20160519.Messages().ByName("SiblingMessage"),
+ }, {
+ got: legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20160519.Message_ChildMessage))),
+ want: fileDescP3_20160519.Messages().ByName("Message").Messages().ByName("ChildMessage"),
+ }, {
+ got: legacyLoadMessageDesc(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))),
+ want: fileDescP2_20180125.Enums().ByName("SiblingEnum"),
+ }, {
+ got: legacyLoadEnumDesc(reflect.TypeOf(proto2_20180125.Message_ChildEnum(0))),
+ want: fileDescP2_20180125.Messages().ByName("Message").Enums().ByName("ChildEnum"),
+ }, {
+ got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180125.SiblingMessage))),
+ want: fileDescP2_20180125.Messages().ByName("SiblingMessage"),
+ }, {
+ got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180125.Message_ChildMessage))),
+ want: fileDescP2_20180125.Messages().ByName("Message").Messages().ByName("ChildMessage"),
+ }, {
+ got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180125.Message))),
+ want: fileDescP2_20180125.Messages().ByName("Message"),
+ }, {
+ got: legacyLoadMessageDesc(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))),
+ want: fileDescP2_20180125.Messages().ByName("Message").Messages().ByName("OptionalGroup"),
+ }, {
+ got: legacyLoadMessageDesc(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))),
+ want: fileDescP2_20180125.Messages().ByName("Message").Messages().ByName("RepeatedGroup"),
+ }, {
+ got: legacyLoadMessageDesc(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))),
+ want: fileDescP2_20180125.Messages().ByName("Message").Messages().ByName("ExtensionOptionalGroup"),
+ }, {
+ got: legacyLoadMessageDesc(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))),
+ want: fileDescP3_20180125.Enums().ByName("SiblingEnum"),
+ }, {
+ got: legacyLoadEnumDesc(reflect.TypeOf(proto3_20180125.Message_ChildEnum(0))),
+ want: fileDescP3_20180125.Messages().ByName("Message").Enums().ByName("ChildEnum"),
+ }, {
+ got: legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20180125.SiblingMessage))),
+ want: fileDescP3_20180125.Messages().ByName("SiblingMessage"),
+ }, {
+ got: legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20180125.Message_ChildMessage))),
+ want: fileDescP3_20180125.Messages().ByName("Message").Messages().ByName("ChildMessage"),
+ }, {
+ got: legacyLoadMessageDesc(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))),
+ want: fileDescP2_20180430.Enums().ByName("SiblingEnum"),
+ }, {
+ got: legacyLoadEnumDesc(reflect.TypeOf(proto2_20180430.Message_ChildEnum(0))),
+ want: fileDescP2_20180430.Messages().ByName("Message").Enums().ByName("ChildEnum"),
+ }, {
+ got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180430.SiblingMessage))),
+ want: fileDescP2_20180430.Messages().ByName("SiblingMessage"),
+ }, {
+ got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180430.Message_ChildMessage))),
+ want: fileDescP2_20180430.Messages().ByName("Message").Messages().ByName("ChildMessage"),
+ }, {
+ got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180430.Message))),
+ want: fileDescP2_20180430.Messages().ByName("Message"),
+ }, {
+ got: legacyLoadMessageDesc(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))),
+ want: fileDescP2_20180430.Messages().ByName("Message").Messages().ByName("OptionalGroup"),
+ }, {
+ got: legacyLoadMessageDesc(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))),
+ want: fileDescP2_20180430.Messages().ByName("Message").Messages().ByName("RepeatedGroup"),
+ }, {
+ got: legacyLoadMessageDesc(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))),
+ want: fileDescP2_20180430.Messages().ByName("Message").Messages().ByName("ExtensionOptionalGroup"),
+ }, {
+ got: legacyLoadMessageDesc(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))),
+ want: fileDescP3_20180430.Enums().ByName("SiblingEnum"),
+ }, {
+ got: legacyLoadEnumDesc(reflect.TypeOf(proto3_20180430.Message_ChildEnum(0))),
+ want: fileDescP3_20180430.Messages().ByName("Message").Enums().ByName("ChildEnum"),
+ }, {
+ got: legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20180430.SiblingMessage))),
+ want: fileDescP3_20180430.Messages().ByName("SiblingMessage"),
+ }, {
+ got: legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20180430.Message_ChildMessage))),
+ want: fileDescP3_20180430.Messages().ByName("Message").Messages().ByName("ChildMessage"),
+ }, {
+ got: legacyLoadMessageDesc(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))),
+ want: fileDescP2_20180814.Enums().ByName("SiblingEnum"),
+ }, {
+ got: legacyLoadEnumDesc(reflect.TypeOf(proto2_20180814.Message_ChildEnum(0))),
+ want: fileDescP2_20180814.Messages().ByName("Message").Enums().ByName("ChildEnum"),
+ }, {
+ got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180814.SiblingMessage))),
+ want: fileDescP2_20180814.Messages().ByName("SiblingMessage"),
+ }, {
+ got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180814.Message_ChildMessage))),
+ want: fileDescP2_20180814.Messages().ByName("Message").Messages().ByName("ChildMessage"),
+ }, {
+ got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20180814.Message))),
+ want: fileDescP2_20180814.Messages().ByName("Message"),
+ }, {
+ got: legacyLoadMessageDesc(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))),
+ want: fileDescP2_20180814.Messages().ByName("Message").Messages().ByName("OptionalGroup"),
+ }, {
+ got: legacyLoadMessageDesc(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))),
+ want: fileDescP2_20180814.Messages().ByName("Message").Messages().ByName("RepeatedGroup"),
+ }, {
+ got: legacyLoadMessageDesc(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))),
+ want: fileDescP2_20180814.Messages().ByName("Message").Messages().ByName("ExtensionOptionalGroup"),
+ }, {
+ got: legacyLoadMessageDesc(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))),
+ want: fileDescP3_20180814.Enums().ByName("SiblingEnum"),
+ }, {
+ got: legacyLoadEnumDesc(reflect.TypeOf(proto3_20180814.Message_ChildEnum(0))),
+ want: fileDescP3_20180814.Messages().ByName("Message").Enums().ByName("ChildEnum"),
+ }, {
+ got: legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20180814.SiblingMessage))),
+ want: fileDescP3_20180814.Messages().ByName("SiblingMessage"),
+ }, {
+ got: legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20180814.Message_ChildMessage))),
+ want: fileDescP3_20180814.Messages().ByName("Message").Messages().ByName("ChildMessage"),
+ }, {
+ got: legacyLoadMessageDesc(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))),
+ want: fileDescP2_20181126.Enums().ByName("SiblingEnum"),
+ }, {
+ got: legacyLoadEnumDesc(reflect.TypeOf(proto2_20181126.Message_ChildEnum(0))),
+ want: fileDescP2_20181126.Messages().ByName("Message").Enums().ByName("ChildEnum"),
+ }, {
+ got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20181126.SiblingMessage))),
+ want: fileDescP2_20181126.Messages().ByName("SiblingMessage"),
+ }, {
+ got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20181126.Message_ChildMessage))),
+ want: fileDescP2_20181126.Messages().ByName("Message").Messages().ByName("ChildMessage"),
+ }, {
+ got: legacyLoadMessageDesc(reflect.TypeOf(new(proto2_20181126.Message))),
+ want: fileDescP2_20181126.Messages().ByName("Message"),
+ }, {
+ got: legacyLoadMessageDesc(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))),
+ want: fileDescP2_20181126.Messages().ByName("Message").Messages().ByName("OptionalGroup"),
+ }, {
+ got: legacyLoadMessageDesc(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))),
+ want: fileDescP2_20181126.Messages().ByName("Message").Messages().ByName("RepeatedGroup"),
+ }, {
+ got: legacyLoadMessageDesc(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))),
+ want: fileDescP2_20181126.Messages().ByName("Message").Messages().ByName("ExtensionOptionalGroup"),
+ }, {
+ got: legacyLoadMessageDesc(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))),
+ want: fileDescP3_20181126.Enums().ByName("SiblingEnum"),
+ }, {
+ got: legacyLoadEnumDesc(reflect.TypeOf(proto3_20181126.Message_ChildEnum(0))),
+ want: fileDescP3_20181126.Messages().ByName("Message").Enums().ByName("ChildEnum"),
+ }, {
+ got: legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20181126.SiblingMessage))),
+ want: fileDescP3_20181126.Messages().ByName("SiblingMessage"),
+ }, {
+ got: legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20181126.Message_ChildMessage))),
+ want: fileDescP3_20181126.Messages().ByName("Message").Messages().ByName("ChildMessage"),
+ }, {
+ got: legacyLoadMessageDesc(reflect.TypeOf(new(proto3_20181126.Message))),
+ want: fileDescP3_20181126.Messages().ByName("Message"),
+ }}...)
+
+ // TODO: We need a test package to compare descriptors.
+ type list interface {
+ Len() int
+ pragma.DoNotImplement
+ }
+ opts := cmp.Options{
+ cmp.Transformer("", func(x list) []interface{} {
+ out := make([]interface{}, x.Len())
+ v := reflect.ValueOf(x)
+ for i := 0; i < x.Len(); i++ {
+ m := v.MethodByName("Get")
+ out[i] = m.Call([]reflect.Value{reflect.ValueOf(i)})[0].Interface()
+ }
+ return out
+ }),
+ cmp.Transformer("", func(x pref.Descriptor) map[string]interface{} {
+ out := make(map[string]interface{})
+ v := reflect.ValueOf(x)
+ for i := 0; i < v.NumMethod(); i++ {
+ name := v.Type().Method(i).Name
+ if m := v.Method(i); m.Type().NumIn() == 0 && m.Type().NumOut() == 1 {
+ switch name {
+ case "Index":
+ // Ignore index since legacy descriptors have no parent.
+ case "Options":
+ // Ignore descriptor options since protos are not cmperable.
+ case "Enums", "Messages", "Extensions":
+ // Ignore nested message and enum declarations since
+ // legacy descriptors are all created standalone.
+ case "OneofType", "ExtendedType", "EnumType", "MessageType":
+ // Avoid descending into a dependency to avoid a cycle.
+ // Just record the full name if available.
+ //
+ // TODO: Cycle support in cmp would be useful here.
+ v := m.Call(nil)[0]
+ if !v.IsNil() {
+ out[name] = v.Interface().(pref.Descriptor).FullName()
+ }
+ default:
+ out[name] = m.Call(nil)[0].Interface()
+ }
+ }
+ }
+ return out
+ }),
+ cmp.Transformer("", func(v pref.Value) interface{} {
+ return v.Interface()
+ }),
+ }
+
+ for _, tt := range tests {
+ t.Run(string(tt.want.FullName()), func(t *testing.T) {
+ if diff := cmp.Diff(&tt.want, &tt.got, opts); diff != "" {
+ t.Errorf("descriptor mismatch (-want, +got):\n%s", diff)
+ }
+ })
+ }
+}
diff --git a/internal/legacy/message.go b/internal/legacy/message.go
new file mode 100644
index 0000000..a81bb2e
--- /dev/null
+++ b/internal/legacy/message.go
@@ -0,0 +1,308 @@
+// 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 legacy
+
+import (
+ "fmt"
+ "reflect"
+ "strings"
+ "sync"
+ "unicode"
+
+ descriptorV1 "github.com/golang/protobuf/protoc-gen-go/descriptor"
+ ptag "github.com/golang/protobuf/v2/internal/encoding/tag"
+ pimpl "github.com/golang/protobuf/v2/internal/impl"
+ scalar "github.com/golang/protobuf/v2/internal/scalar"
+ pref "github.com/golang/protobuf/v2/reflect/protoreflect"
+ ptype "github.com/golang/protobuf/v2/reflect/prototype"
+)
+
+// legacyWrapMessage 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())
+ return mt.MessageOf(v.Interface()).Interface()
+}
+
+var messageTypeCache sync.Map // map[reflect.Type]*MessageType
+
+// legacyLoadMessageType 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 {
+ // 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)
+ mt := new(pimpl.MessageType)
+ mt.Type = ptype.GoMessage(md, func(pref.MessageType) pref.ProtoMessage {
+ p := reflect.New(t.Elem()).Interface()
+ return mt.MessageOf(p).Interface()
+ })
+ messageTypeCache.Store(t, mt)
+ return mt
+}
+
+var messageDescCache sync.Map // map[reflect.Type]protoreflect.MessageDescriptor
+
+// legacyLoadMessageDesc 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 {
+ return messageDescSet{}.Load(t)
+}
+
+type messageDescSet struct {
+ visited map[reflect.Type]*ptype.StandaloneMessage
+ descs []*ptype.StandaloneMessage
+ types []reflect.Type
+}
+
+func (ms messageDescSet) Load(t reflect.Type) pref.MessageDescriptor {
+ // Fast-path: check if a MessageDescriptor is cached for this concrete type.
+ if mi, ok := messageDescCache.Load(t); ok {
+ return mi.(pref.MessageDescriptor)
+ }
+
+ // Slow-path: initialize MessageDescriptor from the Go type.
+
+ // Processing t recursively populates descs and types with all sub-messages.
+ // The descriptor for the first type is guaranteed to be at the front.
+ ms.processMessage(t)
+
+ // Within a proto file it is possible for cyclic dependencies to exist
+ // between multiple message types. When these cases arise, the set of
+ // message descriptors must be created together.
+ mds, err := ptype.NewMessages(ms.descs)
+ if err != nil {
+ panic(err)
+ }
+ for i, md := range mds {
+ // Protobuf semantics represents map entries under-the-hood as
+ // pseudo-messages (has a descriptor, but no generated Go type).
+ // Avoid caching these fake messages.
+ if t := ms.types[i]; t.Kind() != reflect.Map {
+ messageDescCache.Store(t, md)
+ }
+ }
+ return mds[0]
+}
+
+func (ms *messageDescSet) processMessage(t reflect.Type) pref.MessageDescriptor {
+ // Fast-path: Obtain a placeholder if the message is already processed.
+ if m, ok := ms.visited[t]; ok {
+ return ptype.PlaceholderMessage(m.FullName)
+ }
+
+ // Slow-path: Walk over the struct fields to derive the message descriptor.
+ if t.Kind() != reflect.Ptr || t.Elem().Kind() != reflect.Struct || t.Elem().PkgPath() == "" {
+ panic(fmt.Sprintf("got %v, want named *struct kind", t))
+ }
+
+ // Derive name and syntax from the raw descriptor.
+ m := new(ptype.StandaloneMessage)
+ mv := reflect.New(t.Elem()).Interface()
+ if _, ok := mv.(pref.ProtoMessage); ok {
+ panic(fmt.Sprintf("%v already implements proto.Message", t))
+ }
+ if md, ok := mv.(legacyMessage); ok {
+ b, idxs := md.Descriptor()
+ fd := legacyLoadFileDesc(b)
+
+ // Derive syntax.
+ switch fd.GetSyntax() {
+ case "proto2", "":
+ m.Syntax = pref.Proto2
+ case "proto3":
+ m.Syntax = pref.Proto3
+ }
+
+ // Derive full name.
+ md := fd.MessageType[idxs[0]]
+ m.FullName = pref.FullName(fd.GetPackage()).Append(pref.Name(md.GetName()))
+ for _, i := range idxs[1:] {
+ md = md.NestedType[i]
+ m.FullName = m.FullName.Append(pref.Name(md.GetName()))
+ }
+ } else {
+ // If the type does not implement legacyMessage, 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.
+ m.FullName = deriveFullName(t.Elem())
+ m.Syntax = pref.Proto2
+
+ // Try to determine if the message is using proto3 by checking scalars.
+ for i := 0; i < t.Elem().NumField(); i++ {
+ f := t.Elem().Field(i)
+ if tag := f.Tag.Get("protobuf"); tag != "" {
+ switch f.Type.Kind() {
+ case reflect.Bool, reflect.Int32, reflect.Int64, reflect.Uint32, reflect.Uint64, reflect.Float32, reflect.Float64, reflect.String:
+ m.Syntax = pref.Proto3
+ }
+ for _, s := range strings.Split(tag, ",") {
+ if s == "proto3" {
+ m.Syntax = pref.Proto3
+ }
+ }
+ }
+ }
+ }
+ ms.visit(m, t)
+
+ // Obtain a list of oneof wrapper types.
+ var oneofWrappers []reflect.Type
+ if fn, ok := t.MethodByName("XXX_OneofFuncs"); ok {
+ vs := fn.Func.Call([]reflect.Value{reflect.Zero(fn.Type.In(0))})[3]
+ for _, v := range vs.Interface().([]interface{}) {
+ oneofWrappers = append(oneofWrappers, reflect.TypeOf(v))
+ }
+ }
+ if fn, ok := t.MethodByName("XXX_OneofWrappers"); ok {
+ vs := fn.Func.Call([]reflect.Value{reflect.Zero(fn.Type.In(0))})[0]
+ for _, v := range vs.Interface().([]interface{}) {
+ oneofWrappers = append(oneofWrappers, reflect.TypeOf(v))
+ }
+ }
+
+ // Obtain a list of the extension ranges.
+ if fn, ok := t.MethodByName("ExtensionRangeArray"); ok {
+ vs := fn.Func.Call([]reflect.Value{reflect.Zero(fn.Type.In(0))})[0]
+ for i := 0; i < vs.Len(); i++ {
+ v := vs.Index(i)
+ m.ExtensionRanges = append(m.ExtensionRanges, [2]pref.FieldNumber{
+ pref.FieldNumber(v.FieldByName("Start").Int()),
+ pref.FieldNumber(v.FieldByName("End").Int() + 1),
+ })
+ }
+ }
+
+ // Derive the message fields by inspecting the struct fields.
+ for i := 0; i < t.Elem().NumField(); i++ {
+ f := t.Elem().Field(i)
+ if tag := f.Tag.Get("protobuf"); tag != "" {
+ tagKey := f.Tag.Get("protobuf_key")
+ tagVal := f.Tag.Get("protobuf_val")
+ m.Fields = append(m.Fields, ms.parseField(tag, tagKey, tagVal, f.Type, m))
+ }
+ if tag := f.Tag.Get("protobuf_oneof"); tag != "" {
+ name := pref.Name(tag)
+ m.Oneofs = append(m.Oneofs, ptype.Oneof{Name: name})
+ for _, t := range oneofWrappers {
+ if t.Implements(f.Type) {
+ f := t.Elem().Field(0)
+ if tag := f.Tag.Get("protobuf"); tag != "" {
+ ft := ms.parseField(tag, "", "", f.Type, m)
+ ft.OneofName = name
+ m.Fields = append(m.Fields, ft)
+ }
+ }
+ }
+ }
+ }
+
+ return ptype.PlaceholderMessage(m.FullName)
+}
+
+func (ms *messageDescSet) parseField(tag, tagKey, tagVal string, goType reflect.Type, parent *ptype.StandaloneMessage) ptype.Field {
+ t := goType
+ isOptional := t.Kind() == reflect.Ptr && t.Elem().Kind() != reflect.Struct
+ isRepeated := t.Kind() == reflect.Slice && t.Elem().Kind() != reflect.Uint8
+ if isOptional || isRepeated {
+ t = t.Elem()
+ }
+ f := ptag.Unmarshal(tag, t)
+
+ // Populate EnumType and MessageType.
+ if f.EnumType == nil && f.Kind == pref.EnumKind {
+ if ev, ok := reflect.Zero(t).Interface().(pref.ProtoEnum); ok {
+ f.EnumType = ev.ProtoReflect().Type()
+ } else {
+ f.EnumType = legacyLoadEnumDesc(t)
+ }
+ }
+ if f.MessageType == nil && (f.Kind == pref.MessageKind || f.Kind == pref.GroupKind) {
+ if mv, ok := reflect.Zero(t).Interface().(pref.ProtoMessage); ok {
+ f.MessageType = mv.ProtoReflect().Type()
+ } else if t.Kind() == reflect.Map {
+ m := &ptype.StandaloneMessage{
+ Syntax: parent.Syntax,
+ FullName: parent.FullName.Append(mapEntryName(f.Name)),
+ Options: &descriptorV1.MessageOptions{MapEntry: scalar.Bool(true)},
+ Fields: []ptype.Field{
+ ms.parseField(tagKey, "", "", t.Key(), nil),
+ ms.parseField(tagVal, "", "", t.Elem(), nil),
+ },
+ }
+ ms.visit(m, t)
+ f.MessageType = ptype.PlaceholderMessage(m.FullName)
+ } else if mv, ok := messageDescCache.Load(t); ok {
+ f.MessageType = mv.(pref.MessageDescriptor)
+ } else {
+ f.MessageType = ms.processMessage(t)
+ }
+ }
+ return f
+}
+
+func (ms *messageDescSet) visit(m *ptype.StandaloneMessage, t reflect.Type) {
+ if ms.visited == nil {
+ ms.visited = make(map[reflect.Type]*ptype.StandaloneMessage)
+ }
+ if t.Kind() != reflect.Map {
+ ms.visited[t] = m
+ }
+ ms.descs = append(ms.descs, m)
+ ms.types = append(ms.types, t)
+}
+
+// deriveFullName derives a fully qualified protobuf name for the given Go type
+// The provided name is not guaranteed to be stable nor universally unique.
+// It should be sufficiently unique within a program.
+func deriveFullName(t reflect.Type) pref.FullName {
+ sanitize := func(r rune) rune {
+ switch {
+ case r == '/':
+ return '.'
+ case 'a' <= r && r <= 'z', 'A' <= r && r <= 'Z', '0' <= r && r <= '9':
+ return r
+ default:
+ return '_'
+ }
+ }
+ prefix := strings.Map(sanitize, t.PkgPath())
+ suffix := strings.Map(sanitize, t.Name())
+ if suffix == "" {
+ suffix = fmt.Sprintf("UnknownX%X", reflect.ValueOf(t).Pointer())
+ }
+
+ ss := append(strings.Split(prefix, "."), suffix)
+ for i, s := range ss {
+ if s == "" || ('0' <= s[0] && s[0] <= '9') {
+ ss[i] = "x" + s
+ }
+ }
+ return pref.FullName(strings.Join(ss, "."))
+}
+
+// mapEntryName derives the message name for a map field of a given name.
+// This is identical to MapEntryName from parser.cc in the protoc source.
+func mapEntryName(s pref.Name) pref.Name {
+ var b []byte
+ nextUpper := true
+ for i := 0; i < len(s); i++ {
+ if c := s[i]; c == '_' {
+ nextUpper = true
+ } else {
+ if nextUpper {
+ c = byte(unicode.ToUpper(rune(c)))
+ nextUpper = false
+ }
+ b = append(b, c)
+ }
+ }
+ return pref.Name(append(b, "Entry"...))
+}