internal/impl: derive descriptors for legacy enums and messages
In order for the v2 rollout to be as seamless as possible, we need to support
the situation where a v2 message depends on some other generated v1 message that
may be stale and does not support the v2 API. In such a situation, there needs
to be some way to wrap a legacy message or enum in such a way that it satisfies
the v2 API.
This wrapping is comprised of two parts:
1) Deriving an enum or message descriptor
2) Providing an reflection implementation for messages
This CL addresses part 1 (while part 2 has already been partially implemented,
since the implementation applies to both v1 and v2).
To derive the enum and message descriptor we rely on a mixture of parsing the
raw descriptor proto and also introspection on the fields in the message.
Methods for obtaining the raw descriptor protos were added in February, 2016,
and so has not always been available. For that reason, we attempt to derive
as much information from the Go type as possible.
As part of this change, we modify prototype to be able to create multiple
standalone messages as a set. This is needed since cyclic dependencies is allowed
between messages within a single proto file.
Change-Id: I71aaf5f977faf9fba03c370b1ee17b3758ce60a6
Reviewed-on: https://go-review.googlesource.com/c/143539
Reviewed-by: Damien Neil <dneil@google.com>
diff --git a/internal/impl/legacy_test.go b/internal/impl/legacy_test.go
new file mode 100644
index 0000000..e182d17
--- /dev/null
+++ b/internal/impl/legacy_test.go
@@ -0,0 +1,133 @@
+// 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 impl
+
+import (
+ "reflect"
+ "testing"
+
+ "github.com/golang/protobuf/v2/internal/pragma"
+ pref "github.com/golang/protobuf/v2/reflect/protoreflect"
+ ptype "github.com/golang/protobuf/v2/reflect/prototype"
+ "github.com/google/go-cmp/cmp"
+)
+
+func mustLoadFileDesc(b []byte) pref.FileDescriptor {
+ fd, err := ptype.NewFileFromDescriptorProto(loadFileDesc(b), nil)
+ if err != nil {
+ panic(err)
+ }
+ return fd
+}
+
+var fileDescLP2 = mustLoadFileDesc(LP2FileDescriptor)
+var fileDescLP3 = mustLoadFileDesc(LP3FileDescriptor)
+
+func TestLegacy(t *testing.T) {
+ tests := []struct {
+ got pref.Descriptor
+ want pref.Descriptor
+ }{{
+ got: loadEnumDesc(reflect.TypeOf(LP2MapEnum(0))),
+ want: fileDescLP2.Enums().ByName("LP2MapEnum"),
+ }, {
+ got: loadEnumDesc(reflect.TypeOf(LP2SiblingEnum(0))),
+ want: fileDescLP2.Enums().ByName("LP2SiblingEnum"),
+ }, {
+ got: loadEnumDesc(reflect.TypeOf(LP2Message_LP2ChildEnum(0))),
+ want: fileDescLP2.Messages().ByName("LP2Message").Enums().ByName("LP2ChildEnum"),
+ }, {
+ got: loadMessageDesc(reflect.TypeOf(new(LP2Message))),
+ want: fileDescLP2.Messages().ByName("LP2Message"),
+ }, {
+ got: loadMessageDesc(reflect.TypeOf(new(LP2Message_LP2ChildMessage))),
+ want: fileDescLP2.Messages().ByName("LP2Message").Messages().ByName("LP2ChildMessage"),
+ }, {
+ got: loadMessageDesc(reflect.TypeOf(new(LP2Message_LP2NamedGroup))),
+ want: fileDescLP2.Messages().ByName("LP2Message").Messages().ByName("LP2NamedGroup"),
+ }, {
+ got: loadMessageDesc(reflect.TypeOf(new(LP2Message_OptionalGroup))),
+ want: fileDescLP2.Messages().ByName("LP2Message").Messages().ByName("OptionalGroup"),
+ }, {
+ got: loadMessageDesc(reflect.TypeOf(new(LP2Message_RequiredGroup))),
+ want: fileDescLP2.Messages().ByName("LP2Message").Messages().ByName("RequiredGroup"),
+ }, {
+ got: loadMessageDesc(reflect.TypeOf(new(LP2Message_RepeatedGroup))),
+ want: fileDescLP2.Messages().ByName("LP2Message").Messages().ByName("RepeatedGroup"),
+ }, {
+ got: loadMessageDesc(reflect.TypeOf(new(LP2SiblingMessage))),
+ want: fileDescLP2.Messages().ByName("LP2SiblingMessage"),
+ }, {
+ got: loadEnumDesc(reflect.TypeOf(LP3SiblingEnum(0))),
+ want: fileDescLP3.Enums().ByName("LP3SiblingEnum"),
+ }, {
+ got: loadEnumDesc(reflect.TypeOf(LP3Message_LP3ChildEnum(0))),
+ want: fileDescLP3.Messages().ByName("LP3Message").Enums().ByName("LP3ChildEnum"),
+ }, {
+ got: loadMessageDesc(reflect.TypeOf(new(LP3Message))),
+ want: fileDescLP3.Messages().ByName("LP3Message"),
+ }, {
+ got: loadMessageDesc(reflect.TypeOf(new(LP3Message_LP3ChildMessage))),
+ want: fileDescLP3.Messages().ByName("LP3Message").Messages().ByName("LP3ChildMessage"),
+ }, {
+ got: loadMessageDesc(reflect.TypeOf(new(LP3SiblingMessage))),
+ want: fileDescLP3.Messages().ByName("LP3SiblingMessage"),
+ }}
+
+ 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 "Messages", "Enums":
+ // Ignore nested message and enum declarations since
+ // legacy descriptors are all created standalone.
+ case "OneofType", "ExtendedType", "MessageType", "EnumType":
+ // 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)
+ }
+ })
+ }
+}