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/encoding/textpb/encode_test.go b/encoding/textpb/encode_test.go
index 28beaf4..ffb2c5a 100644
--- a/encoding/textpb/encode_test.go
+++ b/encoding/textpb/encode_test.go
@@ -10,8 +10,6 @@
"testing"
"github.com/golang/protobuf/v2/encoding/textpb"
- "github.com/golang/protobuf/v2/encoding/textpb/testprotos/pb2"
- "github.com/golang/protobuf/v2/encoding/textpb/testprotos/pb3"
"github.com/golang/protobuf/v2/internal/detrand"
"github.com/golang/protobuf/v2/internal/impl"
"github.com/golang/protobuf/v2/internal/scalar"
@@ -19,12 +17,18 @@
"github.com/google/go-cmp/cmp"
"github.com/google/go-cmp/cmp/cmpopts"
+ // The legacy package must be imported prior to use of any legacy messages.
+ // TODO: Remove this when protoV1 registers these hooks for you.
+ _ "github.com/golang/protobuf/v2/internal/legacy"
+
anypb "github.com/golang/protobuf/ptypes/any"
durpb "github.com/golang/protobuf/ptypes/duration"
emptypb "github.com/golang/protobuf/ptypes/empty"
stpb "github.com/golang/protobuf/ptypes/struct"
tspb "github.com/golang/protobuf/ptypes/timestamp"
wpb "github.com/golang/protobuf/ptypes/wrappers"
+ "github.com/golang/protobuf/v2/encoding/textpb/testprotos/pb2"
+ "github.com/golang/protobuf/v2/encoding/textpb/testprotos/pb3"
)
func init() {
@@ -33,7 +37,7 @@
}
func M(m interface{}) proto.Message {
- return impl.MessageOf(m).Interface()
+ return impl.Export{}.MessageOf(m).Interface()
}
// splitLines is a cmpopts.Option for comparing strings with line breaks.
diff --git a/internal/impl/export.go b/internal/impl/export.go
new file mode 100644
index 0000000..7e2d392
--- /dev/null
+++ b/internal/impl/export.go
@@ -0,0 +1,76 @@
+// 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 (
+ pref "github.com/golang/protobuf/v2/reflect/protoreflect"
+ ptype "github.com/golang/protobuf/v2/reflect/prototype"
+)
+
+// 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{}
+
+// EnumOf returns the protoreflect.Enum interface over e.
+// If e already implements proto.Enum, then it directly calls the
+// ProtoReflect method, otherwise it wraps the v1 enum to implement
+// the v2 reflective interface.
+func (Export) EnumOf(e interface{}) pref.Enum {
+ if ev, ok := e.(pref.ProtoEnum); ok {
+ return ev.ProtoReflect()
+ }
+ return legacyWrapper.EnumOf(e)
+}
+
+// EnumTypeOf returns the protoreflect.EnumType for e.
+// If e already implements proto.Enum, then it obtains the type by directly
+// calling the ProtoReflect.Type method, otherwise it derives an enum type
+// from the v1 named int32 type.
+func (Export) EnumTypeOf(e interface{}) pref.EnumType {
+ if ev, ok := e.(pref.ProtoEnum); ok {
+ return ev.ProtoReflect().Type()
+ }
+ return legacyWrapper.EnumTypeOf(e)
+}
+
+// MessageOf returns the protoreflect.Message interface over m.
+// If m already implements proto.Message, then it directly calls the
+// ProtoReflect method, otherwise it wraps the v1 message to implement
+// the v2 reflective interface.
+func (Export) MessageOf(m interface{}) pref.Message {
+ if mv, ok := m.(pref.ProtoMessage); ok {
+ return mv.ProtoReflect()
+ }
+ return legacyWrapper.MessageOf(m)
+}
+
+// MessageTypeOf returns the protoreflect.MessageType for m.
+// If m already implements proto.Message, then it obtains the type by directly
+// calling the ProtoReflect.Type method, otherwise it derives a message type
+// from the v1 message struct.
+func (Export) MessageTypeOf(m interface{}) pref.MessageType {
+ if mv, ok := m.(pref.ProtoMessage); ok {
+ return mv.ProtoReflect().Type()
+ }
+ return legacyWrapper.MessageTypeOf(m)
+}
+
+// ExtensionTypeOf returns a protoreflect.ExtensionType where the type of the
+// field is t. The type t must be provided if the field is an enum or message.
+// If t already implements proto.Enum or proto.Message, then this returns
+// an extension type by directly calling prototype.GoExtension.
+// Otherwise, it derives an extension type by wrapping the enum or message
+// using EnumOf or MessageOf.
+func (Export) ExtensionTypeOf(d pref.ExtensionDescriptor, t interface{}) pref.ExtensionType {
+ switch t := t.(type) {
+ case nil:
+ return ptype.GoExtension(d, nil, nil)
+ case pref.ProtoEnum:
+ return ptype.GoExtension(d, t.ProtoReflect().Type(), nil)
+ case pref.ProtoMessage:
+ return ptype.GoExtension(d, nil, t.ProtoReflect().Type())
+ }
+ return legacyWrapper.ExtensionTypeOf(d, t)
+}
diff --git a/internal/impl/legacy_extension.go b/internal/impl/legacy_extension.go
index d87892f..df92f02 100644
--- a/internal/impl/legacy_extension.go
+++ b/internal/impl/legacy_extension.go
@@ -5,14 +5,10 @@
package impl
import (
- "fmt"
"reflect"
papi "github.com/golang/protobuf/protoapi"
- ptag "github.com/golang/protobuf/v2/internal/encoding/tag"
- 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 makeLegacyExtensionFieldsFunc(t reflect.Type) func(p *messageDataType) pref.KnownFields {
@@ -71,7 +67,7 @@
if x.Value == nil {
return false
}
- t := legacyExtensionTypeOf(x.Desc)
+ t := legacyWrapper.ExtensionTypeFromDesc(x.Desc)
if t.Cardinality() == pref.Repeated {
return t.ValueOf(x.Value).List().Len() > 0
}
@@ -83,7 +79,7 @@
if x.Desc == nil {
return pref.Value{}
}
- t := legacyExtensionTypeOf(x.Desc)
+ t := legacyWrapper.ExtensionTypeFromDesc(x.Desc)
if x.Value == nil {
// NOTE: x.Value is never nil for Lists since they are always populated
// during ExtensionFieldTypes.Register.
@@ -100,7 +96,7 @@
if x.Desc == nil {
panic("no extension descriptor registered")
}
- t := legacyExtensionTypeOf(x.Desc)
+ t := legacyWrapper.ExtensionTypeFromDesc(x.Desc)
x.Value = t.InterfaceOf(v)
p.x.Set(n, x)
}
@@ -110,7 +106,7 @@
if x.Desc == nil {
return
}
- t := legacyExtensionTypeOf(x.Desc)
+ t := legacyWrapper.ExtensionTypeFromDesc(x.Desc)
if t.Cardinality() == pref.Repeated {
t.ValueOf(x.Value).List().Truncate(0)
return
@@ -124,7 +120,7 @@
if x.Desc == nil {
panic("no extension descriptor registered")
}
- t := legacyExtensionTypeOf(x.Desc)
+ t := legacyWrapper.ExtensionTypeFromDesc(x.Desc)
if x.Value == nil {
v := t.ValueOf(t.New())
x.Value = t.InterfaceOf(v)
@@ -169,7 +165,7 @@
if x.Desc != nil {
panic("extension descriptor already registered")
}
- x.Desc = legacyExtensionDescOf(t, p.mi.goType)
+ x.Desc = legacyWrapper.ExtensionDescFromType(t)
if t.Cardinality() == pref.Repeated {
// If the field is repeated, initialize the entry with an empty list
// so that future Get operations can return a mutable and concrete list.
@@ -204,7 +200,7 @@
func (p legacyExtensionTypes) ByNumber(n pref.FieldNumber) pref.ExtensionType {
x := p.x.Get(n)
if x.Desc != nil {
- return legacyExtensionTypeOf(x.Desc)
+ return legacyWrapper.ExtensionTypeFromDesc(x.Desc)
}
return nil
}
@@ -212,7 +208,7 @@
func (p legacyExtensionTypes) ByName(s pref.FullName) (t pref.ExtensionType) {
p.x.Range(func(_ pref.FieldNumber, x papi.ExtensionField) bool {
if x.Desc != nil && x.Desc.Name == string(s) {
- t = legacyExtensionTypeOf(x.Desc)
+ t = legacyWrapper.ExtensionTypeFromDesc(x.Desc)
return false
}
return true
@@ -223,169 +219,10 @@
func (p legacyExtensionTypes) Range(f func(pref.ExtensionType) bool) {
p.x.Range(func(_ pref.FieldNumber, x papi.ExtensionField) bool {
if x.Desc != nil {
- if !f(legacyExtensionTypeOf(x.Desc)) {
+ if !f(legacyWrapper.ExtensionTypeFromDesc(x.Desc)) {
return false
}
}
return true
})
}
-
-func legacyExtensionDescOf(t pref.ExtensionType, parent reflect.Type) *papi.ExtensionDesc {
- if t, ok := t.(*legacyExtensionType); ok {
- return t.desc
- }
-
- // 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 {
- enumName = t.GoType().Name()
- for d, ok := pref.Descriptor(t.EnumType()), true; ok; d, ok = d.Parent() {
- if fd, _ := d.(pref.FileDescriptor); fd != nil && fd.Package() != "" {
- enumName = string(fd.Package()) + "." + enumName
- }
- }
- }
-
- // Construct and return a v1 ExtensionDesc.
- return &papi.ExtensionDesc{
- ExtendedType: reflect.Zero(parent).Interface().(papi.Message),
- ExtensionType: reflect.Zero(extType).Interface(),
- Field: int32(t.Number()),
- Name: string(t.FullName()),
- Tag: ptag.Marshal(t, enumName),
- }
-}
-
-func legacyExtensionTypeOf(d *papi.ExtensionDesc) pref.ExtensionType {
- if d.Type != nil {
- return d.Type
- }
-
- // 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 := newConverter(t, f.Kind)
- 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: legacyLoadMessageDesc(reflect.TypeOf(d.ExtendedType)),
- })
- if err != nil {
- panic(err)
- }
- xt := ptype.GoExtension(xd, conv.EnumType, conv.MessageType)
-
- // Return the extension type as is if the dependencies already support v2.
- xt2 := &legacyExtensionType{ExtensionType: xt, desc: d}
- if !conv.IsLegacy {
- return xt2
- }
-
- // If the dependency is a v1 enum or message, we need to create a custom
- // extension type where ExtensionType.GoType continues to use the legacy
- // v1 Go type, instead of the wrapped versions that satisfy the v2 API.
- if xd.Cardinality() != pref.Repeated {
- // Custom extension type for singular enums and messages.
- // The legacy wrappers use legacyEnumWrapper and legacyMessageWrapper
- // to implement the v2 interfaces for enums and messages.
- // Both of those type satisfy the value.Unwrapper interface.
- 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(legacyWrapEnum(reflect.ValueOf(v)))
- } else {
- return xt.ValueOf(legacyWrapMessage(reflect.ValueOf(v)))
- }
- }
- xt2.interfaceOf = func(v pref.Value) interface{} {
- return xt.InterfaceOf(v).(pvalue.Unwrapper).ProtoUnwrap()
- }
- } else {
- // Custom extension type for repeated enums and messages.
- 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
- desc *papi.ExtensionDesc
- typ reflect.Type
- new func() interface{}
- valueOf func(interface{}) pref.Value
- interfaceOf func(pref.Value) interface{}
-}
-
-func (x *legacyExtensionType) GoType() reflect.Type {
- if x.typ != nil {
- return x.typ
- }
- return x.ExtensionType.GoType()
-}
-func (x *legacyExtensionType) New() interface{} {
- if x.new != nil {
- return x.new()
- }
- return x.ExtensionType.New()
-}
-func (x *legacyExtensionType) ValueOf(v interface{}) pref.Value {
- if x.valueOf != nil {
- return x.valueOf(v)
- }
- return x.ExtensionType.ValueOf(v)
-}
-func (x *legacyExtensionType) InterfaceOf(v pref.Value) interface{} {
- if x.interfaceOf != nil {
- return x.interfaceOf(v)
- }
- return x.ExtensionType.InterfaceOf(v)
-}
diff --git a/internal/impl/legacy_hook.go b/internal/impl/legacy_hook.go
new file mode 100644
index 0000000..86fe95e
--- /dev/null
+++ b/internal/impl/legacy_hook.go
@@ -0,0 +1,17 @@
+// 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 pvalue "github.com/golang/protobuf/v2/internal/value"
+
+// TODO: Add a default LegacyWrapper that panics with a more helpful message?
+var legacyWrapper pvalue.LegacyWrapper
+
+// RegisterLegacyWrapper registers a set of constructor functions that are
+// called when a legacy enum or message is encountered that does not natively
+// support the protobuf reflection APIs.
+func RegisterLegacyWrapper(w pvalue.LegacyWrapper) {
+ legacyWrapper = w
+}
diff --git a/internal/impl/legacy_test.go b/internal/impl/legacy_test.go
index f1fe38f..631879b 100644
--- a/internal/impl/legacy_test.go
+++ b/internal/impl/legacy_test.go
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-package impl
+package impl_test
import (
"bytes"
@@ -12,437 +12,21 @@
papi "github.com/golang/protobuf/protoapi"
pack "github.com/golang/protobuf/v2/internal/encoding/pack"
+ pimpl "github.com/golang/protobuf/v2/internal/impl"
pragma "github.com/golang/protobuf/v2/internal/pragma"
scalar "github.com/golang/protobuf/v2/internal/scalar"
pref "github.com/golang/protobuf/v2/reflect/protoreflect"
ptype "github.com/golang/protobuf/v2/reflect/prototype"
cmp "github.com/google/go-cmp/cmp"
+ cmpopts "github.com/google/go-cmp/cmp/cmpopts"
- 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"
+ // The legacy package must be imported prior to use of any legacy messages.
+ // TODO: Remove this when protoV1 registers these hooks for you.
+ plegacy "github.com/golang/protobuf/v2/internal/legacy"
+
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 TestLegacyDescriptor(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"),
- }}...)
-
- 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)
- }
- })
- }
-}
-
type legacyTestMessage struct {
XXX_unrecognized []byte
papi.XXX_InternalExtensions
@@ -486,7 +70,7 @@
}
m := new(legacyTestMessage)
- fs := MessageOf(m).UnknownFields()
+ fs := pimpl.Export{}.MessageOf(m).UnknownFields()
if got, want := fs.Len(), 0; got != want {
t.Errorf("Len() = %d, want %d", got, want)
@@ -682,175 +266,310 @@
})
}
-func TestLegactExtensions(t *testing.T) {
- extensions := []pref.ExtensionType{
- legacyExtensionTypeOf(&papi.ExtensionDesc{
- ExtendedType: (*legacyTestMessage)(nil),
- ExtensionType: (*bool)(nil),
- Field: 10000,
- Name: "fizz.buzz.optional_bool",
- Tag: "varint,10000,opt,name=optional_bool,json=optionalBool,def=1",
- Filename: "fizz/buzz/test.proto",
- }),
- legacyExtensionTypeOf(&papi.ExtensionDesc{
- ExtendedType: (*legacyTestMessage)(nil),
- ExtensionType: (*int32)(nil),
- Field: 10001,
- Name: "fizz.buzz.optional_int32",
- Tag: "varint,10001,opt,name=optional_int32,json=optionalInt32,def=-12345",
- Filename: "fizz/buzz/test.proto",
- }),
- legacyExtensionTypeOf(&papi.ExtensionDesc{
- ExtendedType: (*legacyTestMessage)(nil),
- ExtensionType: (*uint32)(nil),
- Field: 10002,
- Name: "fizz.buzz.optional_uint32",
- Tag: "varint,10002,opt,name=optional_uint32,json=optionalUint32,def=3200",
- Filename: "fizz/buzz/test.proto",
- }),
- legacyExtensionTypeOf(&papi.ExtensionDesc{
- ExtendedType: (*legacyTestMessage)(nil),
- ExtensionType: (*float32)(nil),
- Field: 10003,
- Name: "fizz.buzz.optional_float",
- Tag: "fixed32,10003,opt,name=optional_float,json=optionalFloat,def=3.14159",
- Filename: "fizz/buzz/test.proto",
- }),
- legacyExtensionTypeOf(&papi.ExtensionDesc{
- ExtendedType: (*legacyTestMessage)(nil),
- ExtensionType: (*string)(nil),
- Field: 10004,
- Name: "fizz.buzz.optional_string",
- Tag: "bytes,10004,opt,name=optional_string,json=optionalString,def=hello, \"world!\"\n",
- Filename: "fizz/buzz/test.proto",
- }),
- legacyExtensionTypeOf(&papi.ExtensionDesc{
- ExtendedType: (*legacyTestMessage)(nil),
- ExtensionType: ([]byte)(nil),
- Field: 10005,
- Name: "fizz.buzz.optional_bytes",
- Tag: "bytes,10005,opt,name=optional_bytes,json=optionalBytes,def=dead\\336\\255\\276\\357beef",
- Filename: "fizz/buzz/test.proto",
- }),
- legacyExtensionTypeOf(&papi.ExtensionDesc{
- ExtendedType: (*legacyTestMessage)(nil),
- ExtensionType: (*proto2_20180125.Message_ChildEnum)(nil),
- Field: 10006,
- Name: "fizz.buzz.optional_enum_v1",
- Tag: "varint,10006,opt,name=optional_enum_v1,json=optionalEnumV1,enum=google.golang.org.proto2_20180125.Message_ChildEnum,def=0",
- Filename: "fizz/buzz/test.proto",
- }),
- legacyExtensionTypeOf(&papi.ExtensionDesc{
- ExtendedType: (*legacyTestMessage)(nil),
- ExtensionType: (*proto2_20180125.Message_ChildMessage)(nil),
- Field: 10007,
- Name: "fizz.buzz.optional_message_v1",
- Tag: "bytes,10007,opt,name=optional_message_v1,json=optionalMessageV1",
- Filename: "fizz/buzz/test.proto",
- }),
- legacyExtensionTypeOf(&papi.ExtensionDesc{
- ExtendedType: (*legacyTestMessage)(nil),
- ExtensionType: (*EnumProto2)(nil),
- Field: 10008,
- Name: "fizz.buzz.optional_enum_v2",
- Tag: "varint,10008,opt,name=optional_enum_v2,json=optionalEnumV2,enum=EnumProto2,def=57005",
- Filename: "fizz/buzz/test.proto",
- }),
- legacyExtensionTypeOf(&papi.ExtensionDesc{
- ExtendedType: (*legacyTestMessage)(nil),
- ExtensionType: (*EnumMessages)(nil),
- Field: 10009,
- Name: "fizz.buzz.optional_message_v2",
- Tag: "bytes,10009,opt,name=optional_message_v2,json=optionalMessageV2",
- Filename: "fizz/buzz/test.proto",
- }),
- legacyExtensionTypeOf(&papi.ExtensionDesc{
- ExtendedType: (*legacyTestMessage)(nil),
- ExtensionType: ([]bool)(nil),
- Field: 10010,
- Name: "fizz.buzz.repeated_bool",
- Tag: "varint,10010,rep,name=repeated_bool,json=repeatedBool",
- Filename: "fizz/buzz/test.proto",
- }),
- legacyExtensionTypeOf(&papi.ExtensionDesc{
- ExtendedType: (*legacyTestMessage)(nil),
- ExtensionType: ([]int32)(nil),
- Field: 10011,
- Name: "fizz.buzz.repeated_int32",
- Tag: "varint,10011,rep,name=repeated_int32,json=repeatedInt32",
- Filename: "fizz/buzz/test.proto",
- }),
- legacyExtensionTypeOf(&papi.ExtensionDesc{
- ExtendedType: (*legacyTestMessage)(nil),
- ExtensionType: ([]uint32)(nil),
- Field: 10012,
- Name: "fizz.buzz.repeated_uint32",
- Tag: "varint,10012,rep,name=repeated_uint32,json=repeatedUint32",
- Filename: "fizz/buzz/test.proto",
- }),
- legacyExtensionTypeOf(&papi.ExtensionDesc{
- ExtendedType: (*legacyTestMessage)(nil),
- ExtensionType: ([]float32)(nil),
- Field: 10013,
- Name: "fizz.buzz.repeated_float",
- Tag: "fixed32,10013,rep,name=repeated_float,json=repeatedFloat",
- Filename: "fizz/buzz/test.proto",
- }),
- legacyExtensionTypeOf(&papi.ExtensionDesc{
- ExtendedType: (*legacyTestMessage)(nil),
- ExtensionType: ([]string)(nil),
- Field: 10014,
- Name: "fizz.buzz.repeated_string",
- Tag: "bytes,10014,rep,name=repeated_string,json=repeatedString",
- Filename: "fizz/buzz/test.proto",
- }),
- legacyExtensionTypeOf(&papi.ExtensionDesc{
- ExtendedType: (*legacyTestMessage)(nil),
- ExtensionType: ([][]byte)(nil),
- Field: 10015,
- Name: "fizz.buzz.repeated_bytes",
- Tag: "bytes,10015,rep,name=repeated_bytes,json=repeatedBytes",
- Filename: "fizz/buzz/test.proto",
- }),
- legacyExtensionTypeOf(&papi.ExtensionDesc{
- ExtendedType: (*legacyTestMessage)(nil),
- ExtensionType: ([]proto2_20180125.Message_ChildEnum)(nil),
- Field: 10016,
- Name: "fizz.buzz.repeated_enum_v1",
- Tag: "varint,10016,rep,name=repeated_enum_v1,json=repeatedEnumV1,enum=google.golang.org.proto2_20180125.Message_ChildEnum",
- Filename: "fizz/buzz/test.proto",
- }),
- legacyExtensionTypeOf(&papi.ExtensionDesc{
- ExtendedType: (*legacyTestMessage)(nil),
- ExtensionType: ([]*proto2_20180125.Message_ChildMessage)(nil),
- Field: 10017,
- Name: "fizz.buzz.repeated_message_v1",
- Tag: "bytes,10017,rep,name=repeated_message_v1,json=repeatedMessageV1",
- Filename: "fizz/buzz/test.proto",
- }),
- legacyExtensionTypeOf(&papi.ExtensionDesc{
- ExtendedType: (*legacyTestMessage)(nil),
- ExtensionType: ([]EnumProto2)(nil),
- Field: 10018,
- Name: "fizz.buzz.repeated_enum_v2",
- Tag: "varint,10018,rep,name=repeated_enum_v2,json=repeatedEnumV2,enum=EnumProto2",
- Filename: "fizz/buzz/test.proto",
- }),
- legacyExtensionTypeOf(&papi.ExtensionDesc{
- ExtendedType: (*legacyTestMessage)(nil),
- ExtensionType: ([]*EnumMessages)(nil),
- Field: 10019,
- Name: "fizz.buzz.repeated_message_v2",
- Tag: "bytes,10019,rep,name=repeated_message_v2,json=repeatedMessageV2",
- Filename: "fizz/buzz/test.proto",
- }),
+func mustMakeExtensionType(x *ptype.StandaloneExtension, v interface{}) pref.ExtensionType {
+ xd, err := ptype.NewExtension(x)
+ if err != nil {
+ panic(xd)
}
+ return pimpl.Export{}.ExtensionTypeOf(xd, v)
+}
+
+var (
+ parentType = pimpl.Export{}.MessageTypeOf((*legacyTestMessage)(nil))
+ enumV1Type = pimpl.Export{}.EnumTypeOf(proto2_20180125.Message_ChildEnum(0))
+ messageV1Type = pimpl.Export{}.MessageTypeOf((*proto2_20180125.Message_ChildMessage)(nil))
+ enumV2Type = enumProto2Type
+ messageV2Type = enumMessagesType.Type
+
+ extensionTypes = []pref.ExtensionType{
+ mustMakeExtensionType(&ptype.StandaloneExtension{
+ FullName: "fizz.buzz.optional_bool",
+ Number: 10000,
+ Cardinality: pref.Optional,
+ Kind: pref.BoolKind,
+ Default: pref.ValueOf(true),
+ ExtendedType: parentType,
+ }, nil),
+ mustMakeExtensionType(&ptype.StandaloneExtension{
+ FullName: "fizz.buzz.optional_int32",
+ Number: 10001,
+ Cardinality: pref.Optional,
+ Kind: pref.Int32Kind,
+ Default: pref.ValueOf(int32(-12345)),
+ ExtendedType: parentType,
+ }, nil),
+ mustMakeExtensionType(&ptype.StandaloneExtension{
+ FullName: "fizz.buzz.optional_uint32",
+ Number: 10002,
+ Cardinality: pref.Optional,
+ Kind: pref.Uint32Kind,
+ Default: pref.ValueOf(uint32(3200)),
+ ExtendedType: parentType,
+ }, nil),
+ mustMakeExtensionType(&ptype.StandaloneExtension{
+ FullName: "fizz.buzz.optional_float",
+ Number: 10003,
+ Cardinality: pref.Optional,
+ Kind: pref.FloatKind,
+ Default: pref.ValueOf(float32(3.14159)),
+ ExtendedType: parentType,
+ }, nil),
+ mustMakeExtensionType(&ptype.StandaloneExtension{
+ FullName: "fizz.buzz.optional_string",
+ Number: 10004,
+ Cardinality: pref.Optional,
+ Kind: pref.StringKind,
+ Default: pref.ValueOf(string("hello, \"world!\"\n")),
+ ExtendedType: parentType,
+ }, nil),
+ mustMakeExtensionType(&ptype.StandaloneExtension{
+ FullName: "fizz.buzz.optional_bytes",
+ Number: 10005,
+ Cardinality: pref.Optional,
+ Kind: pref.BytesKind,
+ Default: pref.ValueOf([]byte("dead\xde\xad\xbe\xefbeef")),
+ ExtendedType: parentType,
+ }, nil),
+ mustMakeExtensionType(&ptype.StandaloneExtension{
+ FullName: "fizz.buzz.optional_enum_v1",
+ Number: 10006,
+ Cardinality: pref.Optional,
+ Kind: pref.EnumKind,
+ Default: pref.ValueOf(pref.EnumNumber(0)),
+ EnumType: enumV1Type,
+ ExtendedType: parentType,
+ }, proto2_20180125.Message_ChildEnum(0)),
+ mustMakeExtensionType(&ptype.StandaloneExtension{
+ FullName: "fizz.buzz.optional_message_v1",
+ Number: 10007,
+ Cardinality: pref.Optional,
+ Kind: pref.MessageKind,
+ MessageType: messageV1Type,
+ ExtendedType: parentType,
+ }, (*proto2_20180125.Message_ChildMessage)(nil)),
+ mustMakeExtensionType(&ptype.StandaloneExtension{
+ FullName: "fizz.buzz.optional_enum_v2",
+ Number: 10008,
+ Cardinality: pref.Optional,
+ Kind: pref.EnumKind,
+ Default: pref.ValueOf(pref.EnumNumber(57005)),
+ EnumType: enumV2Type,
+ ExtendedType: parentType,
+ }, EnumProto2(0)),
+ mustMakeExtensionType(&ptype.StandaloneExtension{
+ FullName: "fizz.buzz.optional_message_v2",
+ Number: 10009,
+ Cardinality: pref.Optional,
+ Kind: pref.MessageKind,
+ MessageType: messageV2Type,
+ ExtendedType: parentType,
+ }, (*EnumMessages)(nil)),
+ mustMakeExtensionType(&ptype.StandaloneExtension{
+ FullName: "fizz.buzz.repeated_bool",
+ Number: 10010,
+ Cardinality: pref.Repeated,
+ Kind: pref.BoolKind,
+ ExtendedType: parentType,
+ }, nil),
+ mustMakeExtensionType(&ptype.StandaloneExtension{
+ FullName: "fizz.buzz.repeated_int32",
+ Number: 10011,
+ Cardinality: pref.Repeated,
+ Kind: pref.Int32Kind,
+ ExtendedType: parentType,
+ }, nil),
+ mustMakeExtensionType(&ptype.StandaloneExtension{
+ FullName: "fizz.buzz.repeated_uint32",
+ Number: 10012,
+ Cardinality: pref.Repeated,
+ Kind: pref.Uint32Kind,
+ ExtendedType: parentType,
+ }, nil),
+ mustMakeExtensionType(&ptype.StandaloneExtension{
+ FullName: "fizz.buzz.repeated_float",
+ Number: 10013,
+ Cardinality: pref.Repeated,
+ Kind: pref.FloatKind,
+ ExtendedType: parentType,
+ }, nil),
+ mustMakeExtensionType(&ptype.StandaloneExtension{
+ FullName: "fizz.buzz.repeated_string",
+ Number: 10014,
+ Cardinality: pref.Repeated,
+ Kind: pref.StringKind,
+ ExtendedType: parentType,
+ }, nil),
+ mustMakeExtensionType(&ptype.StandaloneExtension{
+ FullName: "fizz.buzz.repeated_bytes",
+ Number: 10015,
+ Cardinality: pref.Repeated,
+ Kind: pref.BytesKind,
+ ExtendedType: parentType,
+ }, nil),
+ mustMakeExtensionType(&ptype.StandaloneExtension{
+ FullName: "fizz.buzz.repeated_enum_v1",
+ Number: 10016,
+ Cardinality: pref.Repeated,
+ Kind: pref.EnumKind,
+ EnumType: enumV1Type,
+ ExtendedType: parentType,
+ }, proto2_20180125.Message_ChildEnum(0)),
+ mustMakeExtensionType(&ptype.StandaloneExtension{
+ FullName: "fizz.buzz.repeated_message_v1",
+ Number: 10017,
+ Cardinality: pref.Repeated,
+ Kind: pref.MessageKind,
+ MessageType: messageV1Type,
+ ExtendedType: parentType,
+ }, (*proto2_20180125.Message_ChildMessage)(nil)),
+ mustMakeExtensionType(&ptype.StandaloneExtension{
+ FullName: "fizz.buzz.repeated_enum_v2",
+ Number: 10018,
+ Cardinality: pref.Repeated,
+ Kind: pref.EnumKind,
+ EnumType: enumV2Type,
+ ExtendedType: parentType,
+ }, EnumProto2(0)),
+ mustMakeExtensionType(&ptype.StandaloneExtension{
+ FullName: "fizz.buzz.repeated_message_v2",
+ Number: 10019,
+ Cardinality: pref.Repeated,
+ Kind: pref.MessageKind,
+ MessageType: messageV2Type,
+ ExtendedType: parentType,
+ }, (*EnumMessages)(nil)),
+ }
+
+ extensionDescs = []*papi.ExtensionDesc{{
+ ExtendedType: (*legacyTestMessage)(nil),
+ ExtensionType: (*bool)(nil),
+ Field: 10000,
+ Name: "fizz.buzz.optional_bool",
+ Tag: "varint,10000,opt,name=optional_bool,def=1",
+ }, {
+ ExtendedType: (*legacyTestMessage)(nil),
+ ExtensionType: (*int32)(nil),
+ Field: 10001,
+ Name: "fizz.buzz.optional_int32",
+ Tag: "varint,10001,opt,name=optional_int32,def=-12345",
+ }, {
+ ExtendedType: (*legacyTestMessage)(nil),
+ ExtensionType: (*uint32)(nil),
+ Field: 10002,
+ Name: "fizz.buzz.optional_uint32",
+ Tag: "varint,10002,opt,name=optional_uint32,def=3200",
+ }, {
+ ExtendedType: (*legacyTestMessage)(nil),
+ ExtensionType: (*float32)(nil),
+ Field: 10003,
+ Name: "fizz.buzz.optional_float",
+ Tag: "fixed32,10003,opt,name=optional_float,def=3.14159",
+ }, {
+ ExtendedType: (*legacyTestMessage)(nil),
+ ExtensionType: (*string)(nil),
+ Field: 10004,
+ Name: "fizz.buzz.optional_string",
+ Tag: "bytes,10004,opt,name=optional_string,def=hello, \"world!\"\n",
+ }, {
+ ExtendedType: (*legacyTestMessage)(nil),
+ ExtensionType: ([]byte)(nil),
+ Field: 10005,
+ Name: "fizz.buzz.optional_bytes",
+ Tag: "bytes,10005,opt,name=optional_bytes,def=dead\\336\\255\\276\\357beef",
+ }, {
+ ExtendedType: (*legacyTestMessage)(nil),
+ ExtensionType: (*proto2_20180125.Message_ChildEnum)(nil),
+ Field: 10006,
+ Name: "fizz.buzz.optional_enum_v1",
+ Tag: "varint,10006,opt,name=optional_enum_v1,enum=google.golang.org.proto2_20180125.Message_ChildEnum,def=0",
+ }, {
+ ExtendedType: (*legacyTestMessage)(nil),
+ ExtensionType: (*proto2_20180125.Message_ChildMessage)(nil),
+ Field: 10007,
+ Name: "fizz.buzz.optional_message_v1",
+ Tag: "bytes,10007,opt,name=optional_message_v1",
+ }, {
+ ExtendedType: (*legacyTestMessage)(nil),
+ ExtensionType: (*EnumProto2)(nil),
+ Field: 10008,
+ Name: "fizz.buzz.optional_enum_v2",
+ Tag: "varint,10008,opt,name=optional_enum_v2,enum=EnumProto2,def=57005",
+ }, {
+ ExtendedType: (*legacyTestMessage)(nil),
+ ExtensionType: (*EnumMessages)(nil),
+ Field: 10009,
+ Name: "fizz.buzz.optional_message_v2",
+ Tag: "bytes,10009,opt,name=optional_message_v2",
+ }, {
+ ExtendedType: (*legacyTestMessage)(nil),
+ ExtensionType: ([]bool)(nil),
+ Field: 10010,
+ Name: "fizz.buzz.repeated_bool",
+ Tag: "varint,10010,rep,name=repeated_bool",
+ }, {
+ ExtendedType: (*legacyTestMessage)(nil),
+ ExtensionType: ([]int32)(nil),
+ Field: 10011,
+ Name: "fizz.buzz.repeated_int32",
+ Tag: "varint,10011,rep,name=repeated_int32",
+ }, {
+ ExtendedType: (*legacyTestMessage)(nil),
+ ExtensionType: ([]uint32)(nil),
+ Field: 10012,
+ Name: "fizz.buzz.repeated_uint32",
+ Tag: "varint,10012,rep,name=repeated_uint32",
+ }, {
+ ExtendedType: (*legacyTestMessage)(nil),
+ ExtensionType: ([]float32)(nil),
+ Field: 10013,
+ Name: "fizz.buzz.repeated_float",
+ Tag: "fixed32,10013,rep,name=repeated_float",
+ }, {
+ ExtendedType: (*legacyTestMessage)(nil),
+ ExtensionType: ([]string)(nil),
+ Field: 10014,
+ Name: "fizz.buzz.repeated_string",
+ Tag: "bytes,10014,rep,name=repeated_string",
+ }, {
+ ExtendedType: (*legacyTestMessage)(nil),
+ ExtensionType: ([][]byte)(nil),
+ Field: 10015,
+ Name: "fizz.buzz.repeated_bytes",
+ Tag: "bytes,10015,rep,name=repeated_bytes",
+ }, {
+ ExtendedType: (*legacyTestMessage)(nil),
+ ExtensionType: ([]proto2_20180125.Message_ChildEnum)(nil),
+ Field: 10016,
+ Name: "fizz.buzz.repeated_enum_v1",
+ Tag: "varint,10016,rep,name=repeated_enum_v1,enum=google.golang.org.proto2_20180125.Message_ChildEnum",
+ }, {
+ ExtendedType: (*legacyTestMessage)(nil),
+ ExtensionType: ([]*proto2_20180125.Message_ChildMessage)(nil),
+ Field: 10017,
+ Name: "fizz.buzz.repeated_message_v1",
+ Tag: "bytes,10017,rep,name=repeated_message_v1",
+ }, {
+ ExtendedType: (*legacyTestMessage)(nil),
+ ExtensionType: ([]EnumProto2)(nil),
+ Field: 10018,
+ Name: "fizz.buzz.repeated_enum_v2",
+ Tag: "varint,10018,rep,name=repeated_enum_v2,enum=EnumProto2",
+ }, {
+ ExtendedType: (*legacyTestMessage)(nil),
+ ExtensionType: ([]*EnumMessages)(nil),
+ Field: 10019,
+ Name: "fizz.buzz.repeated_message_v2",
+ Tag: "bytes,10019,rep,name=repeated_message_v2",
+ }}
+)
+
+func TestLegacyExtensions(t *testing.T) {
opts := cmp.Options{cmp.Comparer(func(x, y *proto2_20180125.Message_ChildMessage) bool {
return x == y // pointer compare messages for object identity
})}
m := new(legacyTestMessage)
- fs := MessageOf(m).KnownFields()
+ fs := pimpl.Export{}.MessageOf(m).KnownFields()
ts := fs.ExtensionTypes()
if n := fs.Len(); n != 0 {
@@ -861,7 +580,7 @@
}
// Register all the extension types.
- for _, xt := range extensions {
+ for _, xt := range extensionTypes {
ts.Register(xt)
}
@@ -889,7 +608,7 @@
new([]EnumProto2),
new([]*EnumMessages),
}
- for i, xt := range extensions {
+ for i, xt := range extensionTypes {
var got interface{}
if v := fs.Get(xt.Number()); v.IsValid() {
got = xt.InterfaceOf(v)
@@ -901,7 +620,7 @@
}
// All fields should be unpopulated.
- for _, xt := range extensions {
+ for _, xt := range extensionTypes {
if fs.Has(xt.Number()) {
t.Errorf("KnownFields.Has(%d) = true, want false", xt.Number())
}
@@ -934,11 +653,11 @@
&[]EnumProto2{0xdead},
&[]*EnumMessages{m2b},
}
- for i, xt := range extensions {
+ for i, xt := range extensionTypes {
fs.Set(xt.Number(), xt.ValueOf(setValues[i]))
}
- for i, xt := range extensions[len(extensions)/2:] {
- v := extensions[i].ValueOf(setValues[i])
+ for i, xt := range extensionTypes[len(extensionTypes)/2:] {
+ v := extensionTypes[i].ValueOf(setValues[i])
fs.Get(xt.Number()).List().Append(v)
}
@@ -965,7 +684,7 @@
&[]EnumProto2{0xdead, 0xbeef},
&[]*EnumMessages{m2b, m2a},
}
- for i, xt := range extensions {
+ for i, xt := range extensionTypes {
got := xt.InterfaceOf(fs.Get(xt.Number()))
want := getValues[i]
if diff := cmp.Diff(want, got, opts); diff != "" {
@@ -981,10 +700,10 @@
}
// Clear the field for all extension types.
- for _, xt := range extensions[:len(extensions)/2] {
+ for _, xt := range extensionTypes[:len(extensionTypes)/2] {
fs.Clear(xt.Number())
}
- for i, xt := range extensions[len(extensions)/2:] {
+ for i, xt := range extensionTypes[len(extensionTypes)/2:] {
if i%2 == 0 {
fs.Clear(xt.Number())
} else {
@@ -999,7 +718,7 @@
}
// De-register all extension types.
- for _, xt := range extensions {
+ for _, xt := range extensionTypes {
ts.Remove(xt)
}
if n := fs.Len(); n != 0 {
@@ -1008,5 +727,78 @@
if n := ts.Len(); n != 0 {
t.Errorf("ExtensionFieldTypes.Len() = %v, want 0", n)
}
+}
+func TestExtensionConvert(t *testing.T) {
+ for i := range extensionTypes {
+ i := i
+ t.Run("", func(t *testing.T) {
+ t.Parallel()
+
+ wantType := extensionTypes[i]
+ wantDesc := extensionDescs[i]
+ gotType := plegacy.Export{}.ExtensionTypeFromDesc(wantDesc)
+ gotDesc := plegacy.Export{}.ExtensionDescFromType(wantType)
+
+ // TODO: We need a test package to compare descriptors.
+ type list interface {
+ Len() int
+ pragma.DoNotImplement
+ }
+ opts := cmp.Options{
+ cmp.Comparer(func(x, y reflect.Type) bool {
+ return x == y
+ }),
+ 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 "New":
+ // Ignore New since it a constructor.
+ case "Options":
+ // Ignore descriptor options since protos are not cmperable.
+ case "EnumType", "MessageType", "ExtendedType":
+ // 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()
+ }),
+ }
+ if diff := cmp.Diff(&wantType, &gotType, opts); diff != "" {
+ t.Errorf("ExtensionType mismatch (-want, +got):\n%v", diff)
+ }
+
+ opts = cmp.Options{
+ cmpopts.IgnoreFields(papi.ExtensionDesc{}, "Type"),
+ }
+ if diff := cmp.Diff(wantDesc, gotDesc, opts); diff != "" {
+ t.Errorf("ExtensionDesc mismatch (-want, +got):\n%v", diff)
+ }
+ })
+ }
}
diff --git a/internal/impl/message.go b/internal/impl/message.go
index c0b1029..089c6e7 100644
--- a/internal/impl/message.go
+++ b/internal/impl/message.go
@@ -11,20 +11,10 @@
"strings"
"sync"
+ pvalue "github.com/golang/protobuf/v2/internal/value"
pref "github.com/golang/protobuf/v2/reflect/protoreflect"
)
-// MessageOf returns the protoreflect.Message interface over p.
-// If p already implements proto.Message, then it directly calls the
-// ProtoReflect method, otherwise it wraps the legacy v1 message to implement
-// the v2 reflective interface.
-func MessageOf(p interface{}) pref.Message {
- if m, ok := p.(pref.ProtoMessage); ok {
- return m.ProtoReflect()
- }
- return legacyWrapMessage(reflect.ValueOf(p)).ProtoReflect()
-}
-
// MessageType provides protobuf related functionality for a given Go type
// that represents a message. A given instance of MessageType is tied to
// exactly one Go type, which must be a pointer to a struct type.
@@ -165,6 +155,10 @@
}
}
+func (mi *MessageType) MessageOf(p interface{}) pref.Message {
+ return (*messageWrapper)(mi.dataTypeOf(p))
+}
+
func (mi *MessageType) KnownFieldsOf(p interface{}) pref.KnownFields {
return (*knownFields)(mi.dataTypeOf(p))
}
@@ -201,6 +195,33 @@
mi *MessageType
}
+type messageWrapper messageDataType
+
+func (m *messageWrapper) Type() pref.MessageType {
+ return m.mi.Type
+}
+func (m *messageWrapper) KnownFields() pref.KnownFields {
+ return (*knownFields)(m)
+}
+func (m *messageWrapper) UnknownFields() pref.UnknownFields {
+ return m.mi.unknownFields((*messageDataType)(m))
+}
+func (m *messageWrapper) Interface() pref.ProtoMessage {
+ if m, ok := m.ProtoUnwrap().(pref.ProtoMessage); ok {
+ return m
+ }
+ return m
+}
+func (m *messageWrapper) ProtoReflect() pref.Message {
+ return m
+}
+func (m *messageWrapper) ProtoUnwrap() interface{} {
+ return m.p.asType(m.mi.goType.Elem()).Interface()
+}
+func (m *messageWrapper) ProtoMutable() {}
+
+var _ pvalue.Unwrapper = (*messageWrapper)(nil)
+
type knownFields messageDataType
func (fs *knownFields) Len() (cnt int) {
diff --git a/internal/impl/message_field.go b/internal/impl/message_field.go
index e92a7ca..681c918 100644
--- a/internal/impl/message_field.go
+++ b/internal/impl/message_field.go
@@ -42,7 +42,7 @@
if !reflect.PtrTo(ot).Implements(ft) {
panic(fmt.Sprintf("invalid type: %v does not implement %v", ot, ft))
}
- conv := newConverter(ot.Field(0).Type, fd.Kind())
+ conv := pvalue.NewLegacyConverter(ot.Field(0).Type, fd.Kind(), legacyWrapper)
fieldOffset := offsetOf(fs)
// TODO: Implement unsafe fast path?
return fieldInfo{
@@ -104,8 +104,8 @@
if ft.Kind() != reflect.Map {
panic(fmt.Sprintf("invalid type: got %v, want map kind", ft))
}
- keyConv := newConverter(ft.Key(), fd.MessageType().Fields().ByNumber(1).Kind())
- valConv := newConverter(ft.Elem(), fd.MessageType().Fields().ByNumber(2).Kind())
+ keyConv := pvalue.NewLegacyConverter(ft.Key(), fd.MessageType().Fields().ByNumber(1).Kind(), legacyWrapper)
+ valConv := pvalue.NewLegacyConverter(ft.Elem(), fd.MessageType().Fields().ByNumber(2).Kind(), legacyWrapper)
fieldOffset := offsetOf(fs)
// TODO: Implement unsafe fast path?
return fieldInfo{
@@ -137,7 +137,7 @@
if ft.Kind() != reflect.Slice {
panic(fmt.Sprintf("invalid type: got %v, want slice kind", ft))
}
- conv := newConverter(ft.Elem(), fd.Kind())
+ conv := pvalue.NewLegacyConverter(ft.Elem(), fd.Kind(), legacyWrapper)
fieldOffset := offsetOf(fs)
// TODO: Implement unsafe fast path?
return fieldInfo{
@@ -177,7 +177,7 @@
ft = ft.Elem()
}
}
- conv := newConverter(ft, fd.Kind())
+ conv := pvalue.NewLegacyConverter(ft, fd.Kind(), legacyWrapper)
fieldOffset := offsetOf(fs)
// TODO: Implement unsafe fast path?
return fieldInfo{
@@ -242,7 +242,7 @@
func fieldInfoForMessage(fd pref.FieldDescriptor, fs reflect.StructField) fieldInfo {
ft := fs.Type
- conv := newConverter(ft, fd.Kind())
+ conv := pvalue.NewLegacyConverter(ft, fd.Kind(), legacyWrapper)
fieldOffset := offsetOf(fs)
// TODO: Implement unsafe fast path?
return fieldInfo{
@@ -279,12 +279,3 @@
},
}
}
-
-// newConverter calls value.NewLegacyConverter with the necessary constructor
-// functions for legacy enum and message support.
-func newConverter(t reflect.Type, k pref.Kind) pvalue.Converter {
- messageType := func(t reflect.Type) pref.MessageType {
- return legacyLoadMessageType(t).Type
- }
- return pvalue.NewLegacyConverter(t, k, legacyLoadEnumType, messageType, legacyWrapMessage)
-}
diff --git a/internal/impl/message_test.go b/internal/impl/message_test.go
index eeb4e7a..d388494 100644
--- a/internal/impl/message_test.go
+++ b/internal/impl/message_test.go
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-package impl
+package impl_test
import (
"fmt"
@@ -12,14 +12,19 @@
protoV1 "github.com/golang/protobuf/proto"
descriptorV1 "github.com/golang/protobuf/protoc-gen-go/descriptor"
+ pimpl "github.com/golang/protobuf/v2/internal/impl"
scalar "github.com/golang/protobuf/v2/internal/scalar"
+ pvalue "github.com/golang/protobuf/v2/internal/value"
pref "github.com/golang/protobuf/v2/reflect/protoreflect"
ptype "github.com/golang/protobuf/v2/reflect/prototype"
cmp "github.com/google/go-cmp/cmp"
cmpopts "github.com/google/go-cmp/cmp/cmpopts"
+ // The legacy package must be imported prior to use of any legacy messages.
+ // TODO: Remove this when protoV1 registers these hooks for you.
+ _ "github.com/golang/protobuf/v2/internal/legacy"
+
proto2_20180125 "github.com/golang/protobuf/v2/internal/testprotos/legacy/proto2.v1.0.0-20180125-92554152"
- pvalue "github.com/golang/protobuf/v2/internal/value"
)
// List of test operations to perform on messages, lists, or maps.
@@ -184,7 +189,7 @@
MapBytes map[MyString]MyBytes
)
-var scalarProto2Type = MessageType{Type: ptype.GoMessage(
+var scalarProto2Type = pimpl.MessageType{Type: ptype.GoMessage(
mustMakeMessageDesc(ptype.StandaloneMessage{
Syntax: pref.Proto2,
FullName: "ScalarProto2",
@@ -279,7 +284,7 @@
MyBytesA MyString `protobuf:"22"`
}
-var scalarProto3Type = MessageType{Type: ptype.GoMessage(
+var scalarProto3Type = pimpl.MessageType{Type: ptype.GoMessage(
mustMakeMessageDesc(ptype.StandaloneMessage{
Syntax: pref.Proto3,
FullName: "ScalarProto3",
@@ -387,7 +392,7 @@
MyBytes4 ListStrings `protobuf:"19"`
}
-var listScalarsType = MessageType{Type: ptype.GoMessage(
+var listScalarsType = pimpl.MessageType{Type: ptype.GoMessage(
mustMakeMessageDesc(ptype.StandaloneMessage{
Syntax: pref.Proto2,
FullName: "ListScalars",
@@ -565,7 +570,7 @@
}
}
-var mapScalarsType = MessageType{Type: ptype.GoMessage(
+var mapScalarsType = pimpl.MessageType{Type: ptype.GoMessage(
mustMakeMessageDesc(ptype.StandaloneMessage{
Syntax: pref.Proto2,
FullName: "MapScalars",
@@ -732,7 +737,7 @@
Union isOneofScalars_Union `protobuf_oneof:"union"`
}
-var oneofScalarsType = MessageType{Type: ptype.GoMessage(
+var oneofScalarsType = pimpl.MessageType{Type: ptype.GoMessage(
mustMakeMessageDesc(ptype.StandaloneMessage{
Syntax: pref.Proto2,
FullName: "OneofScalars",
@@ -933,14 +938,14 @@
Union isEnumMessages_Union `protobuf_oneof:"union"`
}
-var enumMessagesType = MessageType{Type: ptype.GoMessage(
+var enumMessagesType = pimpl.MessageType{Type: ptype.GoMessage(
mustMakeMessageDesc(ptype.StandaloneMessage{
Syntax: pref.Proto2,
FullName: "EnumMessages",
Fields: []ptype.Field{
{Name: "f1", Number: 1, Cardinality: pref.Optional, Kind: pref.EnumKind, Default: V("BEEF"), EnumType: enumProto2Type},
{Name: "f2", Number: 2, Cardinality: pref.Optional, Kind: pref.EnumKind, Default: V("BRAVO"), EnumType: enumProto3Type},
- {Name: "f3", Number: 3, Cardinality: pref.Optional, Kind: pref.MessageKind, MessageType: MessageOf(new(proto2_20180125.Message)).Type()},
+ {Name: "f3", Number: 3, Cardinality: pref.Optional, Kind: pref.MessageKind, MessageType: pimpl.Export{}.MessageOf(new(proto2_20180125.Message)).Type()},
{Name: "f4", Number: 4, Cardinality: pref.Optional, Kind: pref.MessageKind, MessageType: ptype.PlaceholderMessage("EnumMessages")},
{Name: "f5", Number: 5, Cardinality: pref.Repeated, Kind: pref.EnumKind, EnumType: enumProto2Type},
{Name: "f6", Number: 6, Cardinality: pref.Repeated, Kind: pref.MessageKind, MessageType: scalarProto2Type.Type},
@@ -1018,7 +1023,7 @@
func (*EnumMessages_OneofM3) isEnumMessages_Union() {}
func TestEnumMessages(t *testing.T) {
- wantL := MessageOf(&proto2_20180125.Message{OptionalFloat: scalar.Float32(math.E)})
+ wantL := pimpl.Export{}.MessageOf(&proto2_20180125.Message{OptionalFloat: scalar.Float32(math.E)})
wantM := &EnumMessages{EnumP2: EnumProto2(1234).Enum()}
wantM2a := &ScalarProto2{Float32: scalar.Float32(math.Pi)}
wantM2b := &ScalarProto2{Float32: scalar.Float32(math.Phi)}
diff --git a/internal/impl/legacy_enum.go b/internal/legacy/enum.go
similarity index 97%
rename from internal/impl/legacy_enum.go
rename to internal/legacy/enum.go
index 497b842..86cc7f2 100644
--- a/internal/impl/legacy_enum.go
+++ b/internal/legacy/enum.go
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-package impl
+package legacy
import (
"fmt"
@@ -17,7 +17,7 @@
)
// legacyWrapEnum wraps v as a protoreflect.ProtoEnum,
-// where v must be a *struct kind and not implement the v2 API already.
+// 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()))
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/impl/legacy_file.go b/internal/legacy/file.go
similarity index 84%
rename from internal/impl/legacy_file.go
rename to internal/legacy/file.go
index 8aaa936..48b4d1c 100644
--- a/internal/impl/legacy_file.go
+++ b/internal/legacy/file.go
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-package impl
+package legacy
import (
"bytes"
@@ -15,6 +15,7 @@
// 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
@@ -66,3 +67,14 @@
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/impl/legacy_message.go b/internal/legacy/message.go
similarity index 89%
rename from internal/impl/legacy_message.go
rename to internal/legacy/message.go
index 6b53e2b..a81bb2e 100644
--- a/internal/impl/legacy_message.go
+++ b/internal/legacy/message.go
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-package impl
+package legacy
import (
"fmt"
@@ -13,8 +13,8 @@
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"
- pvalue "github.com/golang/protobuf/v2/internal/value"
pref "github.com/golang/protobuf/v2/reflect/protoreflect"
ptype "github.com/golang/protobuf/v2/reflect/prototype"
)
@@ -23,58 +23,30 @@
// 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 (*legacyMessageWrapper)(mt.dataTypeOf(v.Interface()))
+ 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) *MessageType {
+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.(*MessageType)
+ return mt.(*pimpl.MessageType)
}
// Slow-path: derive message descriptor and initialize MessageType.
md := legacyLoadMessageDesc(t)
- mt := new(MessageType)
+ mt := new(pimpl.MessageType)
mt.Type = ptype.GoMessage(md, func(pref.MessageType) pref.ProtoMessage {
p := reflect.New(t.Elem()).Interface()
- return (*legacyMessageWrapper)(mt.dataTypeOf(p))
+ return mt.MessageOf(p).Interface()
})
messageTypeCache.Store(t, mt)
return mt
}
-type legacyMessageWrapper messageDataType
-
-func (m *legacyMessageWrapper) Type() pref.MessageType {
- return m.mi.Type
-}
-func (m *legacyMessageWrapper) KnownFields() pref.KnownFields {
- return (*knownFields)(m)
-}
-func (m *legacyMessageWrapper) UnknownFields() pref.UnknownFields {
- return m.mi.unknownFields((*messageDataType)(m))
-}
-func (m *legacyMessageWrapper) Interface() pref.ProtoMessage {
- return m
-}
-func (m *legacyMessageWrapper) ProtoReflect() pref.Message {
- return m
-}
-func (m *legacyMessageWrapper) ProtoUnwrap() interface{} {
- return m.p.asType(m.mi.goType.Elem()).Interface()
-}
-func (m *legacyMessageWrapper) ProtoMutable() {}
-
-var (
- _ pref.Message = (*legacyMessageWrapper)(nil)
- _ pref.ProtoMessage = (*legacyMessageWrapper)(nil)
- _ pvalue.Unwrapper = (*legacyMessageWrapper)(nil)
-)
-
var messageDescCache sync.Map // map[reflect.Type]protoreflect.MessageDescriptor
// legacyLoadMessageDesc returns an MessageDescriptor derived from the Go type,
diff --git a/internal/value/convert.go b/internal/value/convert.go
index cc9d94d..5f4109a 100644
--- a/internal/value/convert.go
+++ b/internal/value/convert.go
@@ -47,23 +47,41 @@
// protoc-gen-go historically generated to be able to automatically wrap some
// v1 messages generated by other forks of protoc-gen-go.
func NewConverter(t reflect.Type, k pref.Kind) Converter {
- return NewLegacyConverter(t, k, nil, nil, nil)
+ return NewLegacyConverter(t, k, nil)
}
-// Legacy enums and messages do not self-report their own protoreflect types.
-// Thus, the caller needs to provide functions for retrieving those when
-// a v1 enum or message is encountered.
+// LegacyWrapper is a set of wrapper methods that wraps legacy v1 Go types
+// to implement the v2 reflection APIs.
type (
- enumTypeOf = func(reflect.Type) pref.EnumType
- messageTypeOf = func(reflect.Type) pref.MessageType
- messageValueOf = func(reflect.Value) pref.ProtoMessage
+ LegacyWrapper interface {
+ EnumOf(interface{}) LegacyEnum
+ EnumTypeOf(interface{}) pref.EnumType
+
+ MessageOf(interface{}) LegacyMessage
+ MessageTypeOf(interface{}) pref.MessageType
+
+ ExtensionTypeOf(pref.ExtensionDescriptor, interface{}) pref.ExtensionType
+
+ // TODO: Remove these eventually. See the TODOs in protoapi.
+ ExtensionDescFromType(pref.ExtensionType) *papi.ExtensionDesc
+ ExtensionTypeFromDesc(*papi.ExtensionDesc) pref.ExtensionType
+ }
+
+ LegacyEnum = interface {
+ pref.Enum
+ ProtoUnwrap() interface{}
+ }
+
+ LegacyMessage = interface {
+ pref.Message
+ ProtoUnwrap() interface{}
+ }
)
// NewLegacyConverter is identical to NewConverter,
// but supports wrapping legacy v1 messages to implement the v2 message API
-// using the provided enumTypeOf, messageTypeOf and messageValueOf functions.
-// The wrapped message must implement Unwrapper.
-func NewLegacyConverter(t reflect.Type, k pref.Kind, etOf enumTypeOf, mtOf messageTypeOf, mvOf messageValueOf) Converter {
+// using the provided LegacyWrapper.
+func NewLegacyConverter(t reflect.Type, k pref.Kind, w LegacyWrapper) Converter {
switch k {
case pref.BoolKind:
if t.Kind() == reflect.Bool {
@@ -125,8 +143,8 @@
}
// Handle v1 enums, which we identify as simply a named int32 type.
- if etOf != nil && t.PkgPath() != "" && t.Kind() == reflect.Int32 {
- et := etOf(t)
+ if w != nil && t.PkgPath() != "" && t.Kind() == reflect.Int32 {
+ et := w.EnumTypeOf(reflect.Zero(t).Interface())
return Converter{
PBValueOf: func(v reflect.Value) pref.Value {
if v.Type() != t {
@@ -164,14 +182,14 @@
}
// Handle v1 messages, which we need to wrap as a v2 message.
- if mtOf != nil && t.Kind() == reflect.Ptr && t.Implements(messageIfaceV1) {
- mt := mtOf(t)
+ if w != nil && t.Kind() == reflect.Ptr && t.Implements(messageIfaceV1) {
+ mt := w.MessageTypeOf(reflect.Zero(t).Interface())
return Converter{
PBValueOf: func(v reflect.Value) pref.Value {
if v.Type() != t {
panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), t))
}
- return pref.ValueOf(mvOf(v).ProtoReflect())
+ return pref.ValueOf(w.MessageOf(v.Interface()))
},
GoValueOf: func(v pref.Value) reflect.Value {
rv := reflect.ValueOf(v.Message().(Unwrapper).ProtoUnwrap())
