internal/filedesc, internal/filetype: initial commit
The internal/fileinit package is split apart into two packages:
* internal/filedesc constructs descriptors from the raw proto.
It is very similar to the previous internal/fileinit package.
* internal/filetype wraps descriptors with Go type information
Overview:
* The internal/fileinit package will be deleted in a future CL.
It is kept around since the v1 repo currently depends on it.
* The internal/prototype package is deleted. All former usages of it
are now using internal/filedesc instead. Most significantly,
the reflect/protodesc package was almost entirely re-written.
* The internal/impl package drops support for messages that do not
have a Descriptor method (pre-2016). This removes a significant amount
of technical debt.
filedesc.Builder to parse raw descriptors.
* The internal/encoding/defval package now handles enum values by name.
Change-Id: I3957bcc8588a70470fd6c7de1122216b80615ab7
Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/182360
Reviewed-by: Damien Neil <dneil@google.com>
diff --git a/internal/impl/legacy_enum.go b/internal/impl/legacy_enum.go
index 6758e74..7cd05bf 100644
--- a/internal/impl/legacy_enum.go
+++ b/internal/impl/legacy_enum.go
@@ -6,12 +6,11 @@
import (
"fmt"
- "math"
"reflect"
"sync"
- ptype "google.golang.org/protobuf/internal/prototype"
pvalue "google.golang.org/protobuf/internal/value"
+ "google.golang.org/protobuf/reflect/protoreflect"
pref "google.golang.org/protobuf/reflect/protoreflect"
"google.golang.org/protobuf/reflect/prototype"
)
@@ -94,78 +93,29 @@
return ed.(pref.EnumDescriptor)
}
- // Slow-path: initialize EnumDescriptor from the proto descriptor.
- if t.Kind() != reflect.Int32 || t.PkgPath() == "" {
- panic(fmt.Sprintf("got %v, want named int32 kind", t))
- }
- if t == legacyEnumNumberType {
- panic(fmt.Sprintf("cannot be %v", t))
- }
-
- // Derive the enum descriptor from the raw descriptor proto.
- e := new(ptype.StandaloneEnum)
+ // Slow-path: initialize EnumDescriptor from the raw descriptor.
ev := reflect.Zero(t).Interface()
if _, ok := ev.(pref.Enum); ok {
panic(fmt.Sprintf("%v already implements proto.Enum", t))
}
- if ed, ok := ev.(enumV1); ok {
- b, idxs := ed.EnumDescriptor()
- fd := legacyLoadFileDesc(b)
-
- // Derive syntax.
- switch fd.GetSyntax() {
- case "proto2", "":
- e.Syntax = pref.Proto2
- case "proto3":
- e.Syntax = pref.Proto3
- }
-
- // Derive the full name and correct enum descriptor.
- var ed *legacyEnumDescriptorProto
- e.FullName = pref.FullName(fd.GetPackage())
- if len(idxs) == 1 {
- ed = fd.EnumType[idxs[0]]
- e.FullName = e.FullName.Append(pref.Name(ed.GetName()))
- } else {
- md := fd.MessageType[idxs[0]]
- e.FullName = e.FullName.Append(pref.Name(md.GetName()))
- for _, i := range idxs[1 : len(idxs)-1] {
- md = md.NestedType[i]
- e.FullName = e.FullName.Append(pref.Name(md.GetName()))
- }
- ed = md.EnumType[idxs[len(idxs)-1]]
- e.FullName = e.FullName.Append(pref.Name(ed.GetName()))
- }
-
- // Derive the enum values.
- for _, vd := range ed.Value {
- e.Values = append(e.Values, ptype.EnumValue{
- Name: pref.Name(vd.GetName()),
- Number: pref.EnumNumber(vd.GetNumber()),
- })
- }
- } else {
- // If the type does not implement enumV1, then there is no reliable
- // way to derive the original protobuf type information.
- // We are unable to use the global enum registry since it is
- // unfortunately keyed by the full name, which we do not know.
- // Furthermore, some generated enums register with a fork of
- // golang/protobuf so the enum may not even be found in the registry.
- //
- // Instead, create a bogus enum descriptor to ensure that
- // most operations continue to work. For example, prototext and protojson
- // will be unable to parse a message with an enum value by name.
- e.Syntax = pref.Proto2
- e.FullName = legacyDeriveFullName(t)
- e.Values = []ptype.EnumValue{{Name: "INVALID", Number: math.MinInt32}}
+ edV1, ok := ev.(enumV1)
+ if !ok {
+ panic(fmt.Sprintf("enum %v is no longer supported; please regenerate", t))
}
+ b, idxs := edV1.EnumDescriptor()
- ed, err := ptype.NewEnum(e)
- if err != nil {
- panic(err)
+ var ed pref.EnumDescriptor
+ if len(idxs) == 1 {
+ ed = legacyLoadFileDesc(b).Enums().Get(idxs[0])
+ } else {
+ md := legacyLoadFileDesc(b).Messages().Get(idxs[0])
+ for _, i := range idxs[1 : len(idxs)-1] {
+ md = md.Messages().Get(i)
+ }
+ ed = md.Enums().Get(idxs[len(idxs)-1])
}
if ed, ok := legacyEnumDescCache.LoadOrStore(t, ed); ok {
- return ed.(pref.EnumDescriptor)
+ return ed.(protoreflect.EnumDescriptor)
}
return ed
}
diff --git a/internal/impl/legacy_extension.go b/internal/impl/legacy_extension.go
index 33ca82c..ca3475f 100644
--- a/internal/impl/legacy_extension.go
+++ b/internal/impl/legacy_extension.go
@@ -11,7 +11,7 @@
"google.golang.org/protobuf/internal/descfmt"
ptag "google.golang.org/protobuf/internal/encoding/tag"
- ptype "google.golang.org/protobuf/internal/prototype"
+ "google.golang.org/protobuf/internal/filedesc"
pvalue "google.golang.org/protobuf/internal/value"
pref "google.golang.org/protobuf/reflect/protoreflect"
preg "google.golang.org/protobuf/reflect/protoregistry"
@@ -112,7 +112,7 @@
}
if ed, ok := reflect.Zero(t).Interface().(enumV1); ok && protoPkg == "" {
b, _ := ed.EnumDescriptor()
- protoPkg = legacyLoadFileDesc(b).GetPackage()
+ protoPkg = string(legacyLoadFileDesc(b).Package())
}
if protoPkg != "" {
@@ -159,46 +159,45 @@
return t.(pref.ExtensionType)
}
- // Derive basic field information from the struct tag.
+ // Resolve enum or message dependencies.
+ var ed pref.EnumDescriptor
+ var md pref.MessageDescriptor
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)
+ switch v := reflect.Zero(t).Interface().(type) {
+ case pref.Enum:
+ ed = v.Descriptor()
+ case enumV1:
+ ed = LegacyLoadEnumDesc(t)
+ case pref.ProtoMessage:
+ md = v.ProtoReflect().Descriptor()
+ case messageV1:
+ md = LegacyLoadMessageDesc(t)
+ }
+
+ // Derive basic field information from the struct tag.
+ var evs pref.EnumValueDescriptors
+ if ed != nil {
+ evs = ed.Values()
+ }
+ fd := ptag.Unmarshal(d.Tag, t, evs).(*filedesc.Field)
// Construct a v2 ExtensionType.
- var ed pref.EnumDescriptor
- var md pref.MessageDescriptor
- switch f.Kind {
- case pref.EnumKind:
- if e, ok := reflect.Zero(t).Interface().(pref.Enum); ok {
- ed = e.Descriptor()
- } else {
- ed = LegacyLoadEnumDesc(t)
- }
- case pref.MessageKind, pref.GroupKind:
- if m, ok := reflect.Zero(t).Interface().(pref.ProtoMessage); ok {
- md = m.ProtoReflect().Descriptor()
- } else {
- md = LegacyLoadMessageDesc(t)
- }
- }
- 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: ed,
- MessageType: md,
- ExtendedType: Export{}.MessageDescriptorOf(d.ExtendedType),
- })
- if err != nil {
- panic(err)
- }
+ xd := &filedesc.Extension{L2: new(filedesc.ExtensionL2)}
+ xd.L0.ParentFile = filedesc.SurrogateProto2
+ xd.L0.FullName = pref.FullName(d.Name)
+ xd.L1.Number = pref.FieldNumber(d.Field)
+ xd.L2.Cardinality = fd.L1.Cardinality
+ xd.L1.Kind = fd.L1.Kind
+ xd.L2.IsPacked = fd.L1.IsPacked
+ xd.L2.Default = fd.L1.Default
+ xd.L1.Extendee = Export{}.MessageDescriptorOf(d.ExtendedType)
+ xd.L2.Enum = ed
+ xd.L2.Message = md
xt := LegacyExtensionTypeOf(xd, t)
// Cache the conversion for both directions.
diff --git a/internal/impl/legacy_extension_test.go b/internal/impl/legacy_extension_test.go
deleted file mode 100644
index 6ccfa40..0000000
--- a/internal/impl/legacy_extension_test.go
+++ /dev/null
@@ -1,75 +0,0 @@
-// 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_test
-
-import (
- "reflect"
- "testing"
-
- pimpl "google.golang.org/protobuf/internal/impl"
- ptype "google.golang.org/protobuf/internal/prototype"
- pref "google.golang.org/protobuf/reflect/protoreflect"
- piface "google.golang.org/protobuf/runtime/protoiface"
-
- proto2_20180125 "google.golang.org/protobuf/internal/testprotos/legacy/proto2.v1.0.0-20180125-92554152"
-)
-
-type legacyExtendedMessage struct {
- XXX_unrecognized []byte
- XXX_InternalExtensions map[int32]pimpl.ExtensionField
-}
-
-func (*legacyExtendedMessage) Reset() {}
-func (*legacyExtendedMessage) String() string { return "" }
-func (*legacyExtendedMessage) ProtoMessage() {}
-func (*legacyExtendedMessage) ExtensionRangeArray() []piface.ExtensionRangeV1 {
- return []piface.ExtensionRangeV1{{Start: 10000, End: 20000}}
-}
-
-func mustMakeExtensionType(x *ptype.StandaloneExtension, v interface{}) pref.ExtensionType {
- xd, err := ptype.NewExtension(x)
- if err != nil {
- panic(err)
- }
- return pimpl.LegacyExtensionTypeOf(xd, reflect.TypeOf(v))
-}
-
-var (
- extParentDesc = pimpl.Export{}.MessageDescriptorOf((*legacyExtendedMessage)(nil))
- extMessageV1Desc = pimpl.Export{}.MessageDescriptorOf((*proto2_20180125.Message_ChildMessage)(nil))
-
- wantType = mustMakeExtensionType(&ptype.StandaloneExtension{
- FullName: "fizz.buzz.optional_message_v1",
- Number: 10007,
- Cardinality: pref.Optional,
- Kind: pref.MessageKind,
- MessageType: extMessageV1Desc,
- ExtendedType: extParentDesc,
- }, (*proto2_20180125.Message_ChildMessage)(nil))
- wantDesc = &piface.ExtensionDescV1{
- ExtendedType: (*legacyExtendedMessage)(nil),
- ExtensionType: (*proto2_20180125.Message_ChildMessage)(nil),
- Field: 10007,
- Name: "fizz.buzz.optional_message_v1",
- Tag: "bytes,10007,opt,name=optional_message_v1",
- }
-)
-
-func BenchmarkConvert(b *testing.B) {
- b.ReportAllocs()
- for i := 0; i < b.N; i++ {
- xd := pimpl.Export{}.ExtensionDescFromType(wantType)
- gotType := pimpl.Export{}.ExtensionTypeFromDesc(xd)
- if gotType != wantType {
- b.Fatalf("ExtensionType mismatch: got %p, want %p", gotType, wantType)
- }
-
- xt := pimpl.Export{}.ExtensionTypeFromDesc(wantDesc)
- gotDesc := pimpl.Export{}.ExtensionDescFromType(xt)
- if gotDesc != wantDesc {
- b.Fatalf("ExtensionDesc mismatch: got %p, want %p", gotDesc, wantDesc)
- }
- }
-}
diff --git a/internal/impl/legacy_file.go b/internal/impl/legacy_file.go
index ddf33f7..b1293c6 100644
--- a/internal/impl/legacy_file.go
+++ b/internal/impl/legacy_file.go
@@ -9,6 +9,10 @@
"compress/gzip"
"io/ioutil"
"sync"
+
+ "google.golang.org/protobuf/internal/filedesc"
+ "google.golang.org/protobuf/reflect/protoreflect"
+ "google.golang.org/protobuf/reflect/protoregistry"
)
// Every enum and message type generated by protoc-gen-go since commit 2fc053c5
@@ -28,7 +32,7 @@
}
)
-var legacyFileDescCache sync.Map // map[*byte]*descriptorpb.FileDescriptorProto
+var legacyFileDescCache sync.Map // map[*byte]protoreflect.FileDescriptor
// legacyLoadFileDesc unmarshals b as a compressed FileDescriptorProto message.
//
@@ -36,10 +40,10 @@
// concatenated series of GZIP files (which would require shenanigans that
// rely on the concatenation properties of both protobufs and GZIP).
// File descriptors generated by protoc-gen-go do not rely on that property.
-func legacyLoadFileDesc(b []byte) *legacyFileDescriptorProto {
+func legacyLoadFileDesc(b []byte) protoreflect.FileDescriptor {
// Fast-path: check whether we already have a cached file descriptor.
if fd, ok := legacyFileDescCache.Load(&b[0]); ok {
- return fd.(*legacyFileDescriptorProto)
+ return fd.(protoreflect.FileDescriptor)
}
// Slow-path: decompress and unmarshal the file descriptor proto.
@@ -47,13 +51,23 @@
if err != nil {
panic(err)
}
- b, err = ioutil.ReadAll(zr)
+ b2, err := ioutil.ReadAll(zr)
if err != nil {
panic(err)
}
- fd := legacyParseFileDescProto(b)
+
+ fd := filedesc.DescBuilder{
+ RawDescriptor: b2,
+ FileRegistry: resolverOnly{protoregistry.GlobalFiles}, // do not register back to global registry
+ }.Build().File
if fd, ok := legacyFileDescCache.LoadOrStore(&b[0], fd); ok {
- return fd.(*legacyFileDescriptorProto)
+ return fd.(protoreflect.FileDescriptor)
}
return fd
}
+
+type resolverOnly struct {
+ *protoregistry.Files
+}
+
+func (resolverOnly) Register(...protoreflect.FileDescriptor) error { return nil }
diff --git a/internal/impl/legacy_message.go b/internal/impl/legacy_message.go
index c54cfc1..58bb07c 100644
--- a/internal/impl/legacy_message.go
+++ b/internal/impl/legacy_message.go
@@ -7,12 +7,9 @@
import (
"fmt"
"reflect"
- "strings"
"sync"
- "unicode"
- ptag "google.golang.org/protobuf/internal/encoding/tag"
- ptype "google.golang.org/protobuf/internal/prototype"
+ "google.golang.org/protobuf/reflect/protoreflect"
pref "google.golang.org/protobuf/reflect/protoreflect"
"google.golang.org/protobuf/reflect/prototype"
)
@@ -50,276 +47,35 @@
return mt
}
-var (
- legacyMessageDescLock sync.Mutex
- legacyMessageDescCache sync.Map // map[reflect.Type]protoreflect.MessageDescriptor
-)
+var legacyMessageDescCache sync.Map // map[reflect.Type]protoreflect.MessageDescriptor
// LegacyLoadMessageDesc returns an MessageDescriptor derived from the Go type,
// which must be a *struct kind and not implement the v2 API already.
//
// This is exported for testing purposes.
func LegacyLoadMessageDesc(t reflect.Type) pref.MessageDescriptor {
- return legacyMessageDescSet{}.Load(t)
-}
-
-type legacyMessageDescSet struct {
- visited map[reflect.Type]*ptype.StandaloneMessage
- descs []*ptype.StandaloneMessage
- types []reflect.Type
-}
-
-func (ms legacyMessageDescSet) Load(t reflect.Type) pref.MessageDescriptor {
// Fast-path: check if a MessageDescriptor is cached for this concrete type.
if mi, ok := legacyMessageDescCache.Load(t); ok {
return mi.(pref.MessageDescriptor)
}
- // Slow-path: initialize MessageDescriptor from the Go type.
- //
- // Hold a global lock during message creation to ensure that each Go type
- // maps to exactly one MessageDescriptor. After obtaining the lock, we must
- // check again whether the message has already been handled.
- legacyMessageDescLock.Lock()
- defer legacyMessageDescLock.Unlock()
- if mi, ok := legacyMessageDescCache.Load(t); ok {
- return mi.(pref.MessageDescriptor)
- }
-
- // Processing t recursively populates descs and types with all sub-messages.
- // The descriptor for the first type is guaranteed to be at the front.
- ms.processMessage(t)
-
- // Within a proto file it is possible for cyclic dependencies to exist
- // between multiple message types. When these cases arise, the set of
- // message descriptors must be created together.
- mds, err := ptype.NewMessages(ms.descs)
- if err != nil {
- panic(err)
- }
- for i, md := range mds {
- // Protobuf semantics represents map entries under-the-hood as
- // pseudo-messages (has a descriptor, but no generated Go type).
- // Avoid caching these fake messages.
- if t := ms.types[i]; t.Kind() != reflect.Map {
- legacyMessageDescCache.Store(t, md)
- }
- }
- return mds[0]
-}
-
-func (ms *legacyMessageDescSet) processMessage(t reflect.Type) pref.MessageDescriptor {
- // Fast-path: Obtain a placeholder if the message is already processed.
- if m, ok := ms.visited[t]; ok {
- return ptype.PlaceholderMessage(m.FullName)
- }
-
- // Slow-path: Walk over the struct fields to derive the message descriptor.
- if t.Kind() != reflect.Ptr || t.Elem().Kind() != reflect.Struct || t.Elem().PkgPath() == "" {
- panic(fmt.Sprintf("got %v, want named *struct kind", t))
- }
-
- // Derive name and syntax from the raw descriptor.
- m := new(ptype.StandaloneMessage)
+ // Slow-path: initialize MessageDescriptor from the raw descriptor.
mv := reflect.New(t.Elem()).Interface()
if _, ok := mv.(pref.ProtoMessage); ok {
panic(fmt.Sprintf("%v already implements proto.Message", t))
}
- if md, ok := mv.(messageV1); ok {
- b, idxs := md.Descriptor()
- fd := legacyLoadFileDesc(b)
+ mdV1, ok := mv.(messageV1)
+ if !ok {
+ panic(fmt.Sprintf("message %v is no longer supported; please regenerate", t))
+ }
+ b, idxs := mdV1.Descriptor()
- // Derive syntax.
- switch fd.GetSyntax() {
- case "proto2", "":
- m.Syntax = pref.Proto2
- case "proto3":
- m.Syntax = pref.Proto3
- }
-
- // Derive full name.
- md := fd.MessageType[idxs[0]]
- m.FullName = pref.FullName(fd.GetPackage()).Append(pref.Name(md.GetName()))
- for _, i := range idxs[1:] {
- md = md.NestedType[i]
- m.FullName = m.FullName.Append(pref.Name(md.GetName()))
- }
- } else {
- // If the type does not implement messageV1, then the only way to
- // obtain the full name is through the registry. However, this is
- // unreliable as some generated messages register with a fork of
- // golang/protobuf, so the registry may not have this information.
- m.FullName = legacyDeriveFullName(t.Elem())
- m.Syntax = pref.Proto2
-
- // Try to determine if the message is using proto3 by checking scalars.
- for i := 0; i < t.Elem().NumField(); i++ {
- f := t.Elem().Field(i)
- if tag := f.Tag.Get("protobuf"); tag != "" {
- switch f.Type.Kind() {
- case reflect.Bool, reflect.Int32, reflect.Int64, reflect.Uint32, reflect.Uint64, reflect.Float32, reflect.Float64, reflect.String:
- m.Syntax = pref.Proto3
- }
- for _, s := range strings.Split(tag, ",") {
- if s == "proto3" {
- m.Syntax = pref.Proto3
- }
- }
- }
- }
+ md := legacyLoadFileDesc(b).Messages().Get(idxs[0])
+ for _, i := range idxs[1:] {
+ md = md.Messages().Get(i)
}
- ms.visit(m, t)
-
- // Obtain a list of oneof wrapper types.
- var oneofWrappers []reflect.Type
- if fn, ok := t.MethodByName("XXX_OneofFuncs"); ok {
- vs := fn.Func.Call([]reflect.Value{reflect.Zero(fn.Type.In(0))})[3]
- for _, v := range vs.Interface().([]interface{}) {
- oneofWrappers = append(oneofWrappers, reflect.TypeOf(v))
- }
+ if md, ok := legacyMessageDescCache.LoadOrStore(t, md); ok {
+ return md.(protoreflect.MessageDescriptor)
}
- if fn, ok := t.MethodByName("XXX_OneofWrappers"); ok {
- vs := fn.Func.Call([]reflect.Value{reflect.Zero(fn.Type.In(0))})[0]
- for _, v := range vs.Interface().([]interface{}) {
- oneofWrappers = append(oneofWrappers, reflect.TypeOf(v))
- }
- }
-
- // Obtain a list of the extension ranges.
- if fn, ok := t.MethodByName("ExtensionRangeArray"); ok {
- vs := fn.Func.Call([]reflect.Value{reflect.Zero(fn.Type.In(0))})[0]
- for i := 0; i < vs.Len(); i++ {
- v := vs.Index(i)
- m.ExtensionRanges = append(m.ExtensionRanges, [2]pref.FieldNumber{
- pref.FieldNumber(v.FieldByName("Start").Int()),
- pref.FieldNumber(v.FieldByName("End").Int() + 1),
- })
- }
- }
-
- // Derive the message fields by inspecting the struct fields.
- for i := 0; i < t.Elem().NumField(); i++ {
- f := t.Elem().Field(i)
- if tag := f.Tag.Get("protobuf"); tag != "" {
- tagKey := f.Tag.Get("protobuf_key")
- tagVal := f.Tag.Get("protobuf_val")
- m.Fields = append(m.Fields, ms.parseField(tag, tagKey, tagVal, f.Type, m))
- }
- if tag := f.Tag.Get("protobuf_oneof"); tag != "" {
- name := pref.Name(tag)
- m.Oneofs = append(m.Oneofs, ptype.Oneof{Name: name})
- for _, t := range oneofWrappers {
- if t.Implements(f.Type) {
- f := t.Elem().Field(0)
- if tag := f.Tag.Get("protobuf"); tag != "" {
- ft := ms.parseField(tag, "", "", f.Type, m)
- ft.OneofName = name
- m.Fields = append(m.Fields, ft)
- }
- }
- }
- }
- }
-
- return ptype.PlaceholderMessage(m.FullName)
-}
-
-func (ms *legacyMessageDescSet) parseField(tag, tagKey, tagVal string, goType reflect.Type, parent *ptype.StandaloneMessage) ptype.Field {
- t := goType
- isOptional := t.Kind() == reflect.Ptr && t.Elem().Kind() != reflect.Struct
- isRepeated := t.Kind() == reflect.Slice && t.Elem().Kind() != reflect.Uint8
- if isOptional || isRepeated {
- t = t.Elem()
- }
- f := ptag.Unmarshal(tag, t)
-
- // Populate EnumType and MessageType.
- if f.EnumType == nil && f.Kind == pref.EnumKind {
- if ev, ok := reflect.Zero(t).Interface().(pref.Enum); ok {
- f.EnumType = ev.Descriptor()
- } else {
- f.EnumType = LegacyLoadEnumDesc(t)
- }
- }
- if f.MessageType == nil && (f.Kind == pref.MessageKind || f.Kind == pref.GroupKind) {
- if mv, ok := reflect.Zero(t).Interface().(pref.ProtoMessage); ok {
- f.MessageType = mv.ProtoReflect().Descriptor()
- } else if t.Kind() == reflect.Map {
- m := &ptype.StandaloneMessage{
- Syntax: parent.Syntax,
- FullName: parent.FullName.Append(legacyMapEntryName(f.Name)),
- IsMapEntry: true,
- Fields: []ptype.Field{
- ms.parseField(tagKey, "", "", t.Key(), nil),
- ms.parseField(tagVal, "", "", t.Elem(), nil),
- },
- }
- ms.visit(m, t)
- f.MessageType = ptype.PlaceholderMessage(m.FullName)
- } else if mv, ok := legacyMessageDescCache.Load(t); ok {
- f.MessageType = mv.(pref.MessageDescriptor)
- } else {
- f.MessageType = ms.processMessage(t)
- }
- }
- return f
-}
-
-func (ms *legacyMessageDescSet) visit(m *ptype.StandaloneMessage, t reflect.Type) {
- if ms.visited == nil {
- ms.visited = make(map[reflect.Type]*ptype.StandaloneMessage)
- }
- if t.Kind() != reflect.Map {
- ms.visited[t] = m
- }
- ms.descs = append(ms.descs, m)
- ms.types = append(ms.types, t)
-}
-
-// legacyDeriveFullName derives a fully qualified protobuf name for the given Go type
-// The provided name is not guaranteed to be stable nor universally unique.
-// It should be sufficiently unique within a program.
-func legacyDeriveFullName(t reflect.Type) pref.FullName {
- sanitize := func(r rune) rune {
- switch {
- case r == '/':
- return '.'
- case 'a' <= r && r <= 'z', 'A' <= r && r <= 'Z', '0' <= r && r <= '9':
- return r
- default:
- return '_'
- }
- }
- prefix := strings.Map(sanitize, t.PkgPath())
- suffix := strings.Map(sanitize, t.Name())
- if suffix == "" {
- suffix = fmt.Sprintf("UnknownX%X", reflect.ValueOf(t).Pointer())
- }
-
- ss := append(strings.Split(prefix, "."), suffix)
- for i, s := range ss {
- if s == "" || ('0' <= s[0] && s[0] <= '9') {
- ss[i] = "x" + s
- }
- }
- return pref.FullName(strings.Join(ss, "."))
-}
-
-// legacyMapEntryName derives the message name for a map field of a given name.
-// This is identical to MapEntryName from parser.cc in the protoc source.
-func legacyMapEntryName(s pref.Name) pref.Name {
- var b []byte
- nextUpper := true
- for i := 0; i < len(s); i++ {
- if c := s[i]; c == '_' {
- nextUpper = true
- } else {
- if nextUpper {
- c = byte(unicode.ToUpper(rune(c)))
- nextUpper = false
- }
- b = append(b, c)
- }
- }
- return pref.Name(append(b, "Entry"...))
+ return md
}
diff --git a/internal/impl/legacy_parse.go b/internal/impl/legacy_parse.go
deleted file mode 100644
index 90ba1b7..0000000
--- a/internal/impl/legacy_parse.go
+++ /dev/null
@@ -1,169 +0,0 @@
-// Copyright 2019 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 (
- "google.golang.org/protobuf/internal/encoding/wire"
- "google.golang.org/protobuf/internal/fieldnum"
-)
-
-// To avoid a dependency from legacy to descriptor.proto, use a hand-written parser
-// for the bits of the descriptor we need.
-//
-// TODO: Consider unifying this with the parser in fileinit.
-
-type legacyFileDescriptorProto struct {
- Syntax string
- Package string
- EnumType []*legacyEnumDescriptorProto
- MessageType []*legacyDescriptorProto
-}
-
-func (fd legacyFileDescriptorProto) GetSyntax() string { return fd.Syntax }
-func (fd legacyFileDescriptorProto) GetPackage() string { return fd.Package }
-
-func legacyParseFileDescProto(b []byte) *legacyFileDescriptorProto {
- fd := &legacyFileDescriptorProto{}
- for len(b) > 0 {
- num, typ, n := wire.ConsumeTag(b)
- legacyParseCheck(n)
- b = b[n:]
- switch typ {
- case wire.BytesType:
- v, n := wire.ConsumeBytes(b)
- b = b[n:]
- switch num {
- case fieldnum.FileDescriptorProto_Syntax:
- fd.Syntax = string(v)
- case fieldnum.FileDescriptorProto_Package:
- fd.Package = string(v)
- case fieldnum.FileDescriptorProto_EnumType:
- fd.EnumType = append(fd.EnumType, legacyParseEnumDescProto(v))
- case fieldnum.FileDescriptorProto_MessageType:
- fd.MessageType = append(fd.MessageType, parseDescProto(v))
- }
- default:
- n := wire.ConsumeFieldValue(num, typ, b)
- legacyParseCheck(n)
- b = b[n:]
- }
- }
- return fd
-}
-
-type legacyDescriptorProto struct {
- Name string
- NestedType []*legacyDescriptorProto
- EnumType []*legacyEnumDescriptorProto
-}
-
-func (md legacyDescriptorProto) GetName() string { return md.Name }
-
-func parseDescProto(b []byte) *legacyDescriptorProto {
- md := &legacyDescriptorProto{}
- for len(b) > 0 {
- num, typ, n := wire.ConsumeTag(b)
- legacyParseCheck(n)
- b = b[n:]
- switch typ {
- case wire.BytesType:
- v, n := wire.ConsumeBytes(b)
- legacyParseCheck(n)
- b = b[n:]
- switch num {
- case fieldnum.DescriptorProto_Name:
- md.Name = string(v)
- case fieldnum.DescriptorProto_NestedType:
- md.NestedType = append(md.NestedType, parseDescProto(v))
- case fieldnum.DescriptorProto_EnumType:
- md.EnumType = append(md.EnumType, legacyParseEnumDescProto(v))
- }
- default:
- n := wire.ConsumeFieldValue(num, typ, b)
- legacyParseCheck(n)
- b = b[n:]
- }
- }
- return md
-}
-
-type legacyEnumDescriptorProto struct {
- Name string
- Value []*legacyEnumValueDescriptorProto
-}
-
-func (ed legacyEnumDescriptorProto) GetName() string { return ed.Name }
-
-func legacyParseEnumDescProto(b []byte) *legacyEnumDescriptorProto {
- ed := &legacyEnumDescriptorProto{}
- for len(b) > 0 {
- num, typ, n := wire.ConsumeTag(b)
- legacyParseCheck(n)
- b = b[n:]
- switch typ {
- case wire.BytesType:
- v, n := wire.ConsumeBytes(b)
- legacyParseCheck(n)
- b = b[n:]
- switch num {
- case fieldnum.EnumDescriptorProto_Name:
- ed.Name = string(v)
- case fieldnum.EnumDescriptorProto_Value:
- ed.Value = append(ed.Value, legacyParseEnumValueDescProto(v))
- }
- default:
- n := wire.ConsumeFieldValue(num, typ, b)
- legacyParseCheck(n)
- b = b[n:]
- }
- }
- return ed
-}
-
-type legacyEnumValueDescriptorProto struct {
- Name string
- Number int32
-}
-
-func (ed legacyEnumValueDescriptorProto) GetName() string { return ed.Name }
-func (ed legacyEnumValueDescriptorProto) GetNumber() int32 { return ed.Number }
-
-func legacyParseEnumValueDescProto(b []byte) *legacyEnumValueDescriptorProto {
- vd := &legacyEnumValueDescriptorProto{}
- for len(b) > 0 {
- num, typ, n := wire.ConsumeTag(b)
- legacyParseCheck(n)
- b = b[n:]
- switch typ {
- case wire.VarintType:
- v, n := wire.ConsumeVarint(b)
- legacyParseCheck(n)
- b = b[n:]
- switch num {
- case fieldnum.EnumValueDescriptorProto_Number:
- vd.Number = int32(v)
- }
- case wire.BytesType:
- v, n := wire.ConsumeBytes(b)
- legacyParseCheck(n)
- b = b[n:]
- switch num {
- case fieldnum.EnumDescriptorProto_Name:
- vd.Name = string(v)
- }
- default:
- n := wire.ConsumeFieldValue(num, typ, b)
- legacyParseCheck(n)
- b = b[n:]
- }
- }
- return vd
-}
-
-func legacyParseCheck(n int) {
- if n < 0 {
- panic(wire.ParseError(n))
- }
-}
diff --git a/internal/impl/legacy_test.go b/internal/impl/legacy_test.go
index fc29cdb..a51ae03 100644
--- a/internal/impl/legacy_test.go
+++ b/internal/impl/legacy_test.go
@@ -5,326 +5,333 @@
package impl_test
import (
+ "fmt"
"reflect"
"sync"
"testing"
"github.com/google/go-cmp/cmp"
"github.com/google/go-cmp/cmp/cmpopts"
+ "google.golang.org/protobuf/encoding/prototext"
pimpl "google.golang.org/protobuf/internal/impl"
- pragma "google.golang.org/protobuf/internal/pragma"
- ptype "google.golang.org/protobuf/internal/prototype"
+ "google.golang.org/protobuf/internal/pragma"
"google.golang.org/protobuf/internal/scalar"
+ "google.golang.org/protobuf/proto"
+ pdesc "google.golang.org/protobuf/reflect/protodesc"
pref "google.golang.org/protobuf/reflect/protoreflect"
preg "google.golang.org/protobuf/reflect/protoregistry"
piface "google.golang.org/protobuf/runtime/protoiface"
proto2_20180125 "google.golang.org/protobuf/internal/testprotos/legacy/proto2.v1.0.0-20180125-92554152"
+ "google.golang.org/protobuf/types/descriptorpb"
)
-type legacyTestMessage struct {
+type LegacyTestMessage struct {
XXX_unrecognized []byte
XXX_InternalExtensions map[int32]pimpl.ExtensionField
}
-func (*legacyTestMessage) Reset() {}
-func (*legacyTestMessage) String() string { return "" }
-func (*legacyTestMessage) ProtoMessage() {}
-func (*legacyTestMessage) ExtensionRangeArray() []piface.ExtensionRangeV1 {
+func (*LegacyTestMessage) Reset() {}
+func (*LegacyTestMessage) String() string { return "" }
+func (*LegacyTestMessage) ProtoMessage() {}
+func (*LegacyTestMessage) ExtensionRangeArray() []piface.ExtensionRangeV1 {
return []piface.ExtensionRangeV1{{Start: 10, End: 20}, {Start: 40, End: 80}, {Start: 10000, End: 20000}}
}
+func (*LegacyTestMessage) Descriptor() ([]byte, []int) { return legacyFD, []int{0} }
+
+var legacyFD = func() []byte {
+ b, _ := proto.Marshal(pdesc.ToFileDescriptorProto(mustMakeFileDesc(`
+ name: "legacy.proto"
+ syntax: "proto2"
+ message_type: [{
+ name: "LegacyTestMessage"
+ extension_range: [{start:10 end:20}, {start:40 end:80}, {start:10000 end:20000}]
+ }]
+ `, nil)))
+ return pimpl.Export{}.CompressGZIP(b)
+}()
func init() {
- mt := pimpl.Export{}.MessageTypeOf(&legacyTestMessage{})
+ mt := pimpl.Export{}.MessageTypeOf((*LegacyTestMessage)(nil))
+ preg.GlobalFiles.Register(mt.ParentFile())
preg.GlobalTypes.Register(mt)
}
+func mustMakeExtensionType(fileDesc, extDesc string, t interface{}, r pdesc.Resolver) pref.ExtensionType {
+ s := fmt.Sprintf(`name:"test.proto" syntax:"proto2" %s extension:[{%s}]`, fileDesc, extDesc)
+ xd := mustMakeFileDesc(s, r).Extensions().Get(0)
+ return pimpl.LegacyExtensionTypeOf(xd, reflect.TypeOf(t))
+}
+
+func mustMakeFileDesc(s string, r pdesc.Resolver) pref.FileDescriptor {
+ pb := new(descriptorpb.FileDescriptorProto)
+ if err := prototext.Unmarshal([]byte(s), pb); err != nil {
+ panic(err)
+ }
+ fd, err := pdesc.NewFile(pb, r)
+ if err != nil {
+ panic(err)
+ }
+ return fd
+}
+
var (
- testParentDesc = pimpl.Export{}.MessageDescriptorOf((*legacyTestMessage)(nil))
+ testParentDesc = pimpl.Export{}.MessageDescriptorOf((*LegacyTestMessage)(nil))
testEnumV1Desc = pimpl.Export{}.EnumDescriptorOf(proto2_20180125.Message_ChildEnum(0))
testMessageV1Desc = pimpl.Export{}.MessageDescriptorOf((*proto2_20180125.Message_ChildMessage)(nil))
testEnumV2Desc = enumProto2Type.Descriptor()
testMessageV2Desc = enumMessagesType.PBType.Descriptor()
+ depReg = preg.NewFiles(
+ testParentDesc.ParentFile(),
+ testEnumV1Desc.ParentFile(),
+ testMessageV1Desc.ParentFile(),
+ testEnumV2Desc.ParentFile(),
+ testMessageV2Desc.ParentFile(),
+ )
extensionTypes = []pref.ExtensionType{
- mustMakeExtensionType(&ptype.StandaloneExtension{
- FullName: "fizz.buzz.optional_bool",
- Number: 10000,
- Cardinality: pref.Optional,
- Kind: pref.BoolKind,
- Default: pref.ValueOf(true),
- ExtendedType: testParentDesc,
- }, nil),
- mustMakeExtensionType(&ptype.StandaloneExtension{
- FullName: "fizz.buzz.optional_int32",
- Number: 10001,
- Cardinality: pref.Optional,
- Kind: pref.Int32Kind,
- Default: pref.ValueOf(int32(-12345)),
- ExtendedType: testParentDesc,
- }, nil),
- mustMakeExtensionType(&ptype.StandaloneExtension{
- FullName: "fizz.buzz.optional_uint32",
- Number: 10002,
- Cardinality: pref.Optional,
- Kind: pref.Uint32Kind,
- Default: pref.ValueOf(uint32(3200)),
- ExtendedType: testParentDesc,
- }, nil),
- mustMakeExtensionType(&ptype.StandaloneExtension{
- FullName: "fizz.buzz.optional_float",
- Number: 10003,
- Cardinality: pref.Optional,
- Kind: pref.FloatKind,
- Default: pref.ValueOf(float32(3.14159)),
- ExtendedType: testParentDesc,
- }, 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: testParentDesc,
- }, 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: testParentDesc,
- }, 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: testEnumV1Desc,
- ExtendedType: testParentDesc,
- }, proto2_20180125.Message_ChildEnum(0)),
- mustMakeExtensionType(&ptype.StandaloneExtension{
- FullName: "fizz.buzz.optional_message_v1",
- Number: 10007,
- Cardinality: pref.Optional,
- Kind: pref.MessageKind,
- MessageType: testMessageV1Desc,
- ExtendedType: testParentDesc,
- }, (*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: testEnumV2Desc,
- ExtendedType: testParentDesc,
- }, EnumProto2(0)),
- mustMakeExtensionType(&ptype.StandaloneExtension{
- FullName: "fizz.buzz.optional_message_v2",
- Number: 10009,
- Cardinality: pref.Optional,
- Kind: pref.MessageKind,
- MessageType: testMessageV2Desc,
- ExtendedType: testParentDesc,
- }, (*EnumMessages)(nil)),
- mustMakeExtensionType(&ptype.StandaloneExtension{
- FullName: "fizz.buzz.repeated_bool",
- Number: 10010,
- Cardinality: pref.Repeated,
- Kind: pref.BoolKind,
- ExtendedType: testParentDesc,
- }, nil),
- mustMakeExtensionType(&ptype.StandaloneExtension{
- FullName: "fizz.buzz.repeated_int32",
- Number: 10011,
- Cardinality: pref.Repeated,
- Kind: pref.Int32Kind,
- ExtendedType: testParentDesc,
- }, nil),
- mustMakeExtensionType(&ptype.StandaloneExtension{
- FullName: "fizz.buzz.repeated_uint32",
- Number: 10012,
- Cardinality: pref.Repeated,
- Kind: pref.Uint32Kind,
- ExtendedType: testParentDesc,
- }, nil),
- mustMakeExtensionType(&ptype.StandaloneExtension{
- FullName: "fizz.buzz.repeated_float",
- Number: 10013,
- Cardinality: pref.Repeated,
- Kind: pref.FloatKind,
- ExtendedType: testParentDesc,
- }, nil),
- mustMakeExtensionType(&ptype.StandaloneExtension{
- FullName: "fizz.buzz.repeated_string",
- Number: 10014,
- Cardinality: pref.Repeated,
- Kind: pref.StringKind,
- ExtendedType: testParentDesc,
- }, nil),
- mustMakeExtensionType(&ptype.StandaloneExtension{
- FullName: "fizz.buzz.repeated_bytes",
- Number: 10015,
- Cardinality: pref.Repeated,
- Kind: pref.BytesKind,
- ExtendedType: testParentDesc,
- }, nil),
- mustMakeExtensionType(&ptype.StandaloneExtension{
- FullName: "fizz.buzz.repeated_enum_v1",
- Number: 10016,
- Cardinality: pref.Repeated,
- Kind: pref.EnumKind,
- EnumType: testEnumV1Desc,
- ExtendedType: testParentDesc,
- }, proto2_20180125.Message_ChildEnum(0)),
- mustMakeExtensionType(&ptype.StandaloneExtension{
- FullName: "fizz.buzz.repeated_message_v1",
- Number: 10017,
- Cardinality: pref.Repeated,
- Kind: pref.MessageKind,
- MessageType: testMessageV1Desc,
- ExtendedType: testParentDesc,
- }, (*proto2_20180125.Message_ChildMessage)(nil)),
- mustMakeExtensionType(&ptype.StandaloneExtension{
- FullName: "fizz.buzz.repeated_enum_v2",
- Number: 10018,
- Cardinality: pref.Repeated,
- Kind: pref.EnumKind,
- EnumType: testEnumV2Desc,
- ExtendedType: testParentDesc,
- }, EnumProto2(0)),
- mustMakeExtensionType(&ptype.StandaloneExtension{
- FullName: "fizz.buzz.repeated_message_v2",
- Number: 10019,
- Cardinality: pref.Repeated,
- Kind: pref.MessageKind,
- MessageType: testMessageV2Desc,
- ExtendedType: testParentDesc,
- }, (*EnumMessages)(nil)),
+ mustMakeExtensionType(
+ `package:"fizz.buzz" dependency:"legacy.proto"`,
+ `name:"optional_bool" number:10000 label:LABEL_OPTIONAL type:TYPE_BOOL default_value:"true" extendee:".LegacyTestMessage"`,
+ nil, depReg,
+ ),
+ mustMakeExtensionType(
+ `package:"fizz.buzz" dependency:"legacy.proto"`,
+ `name:"optional_int32" number:10001 label:LABEL_OPTIONAL type:TYPE_INT32 default_value:"-12345" extendee:".LegacyTestMessage"`,
+ nil, depReg,
+ ),
+ mustMakeExtensionType(
+ `package:"fizz.buzz" dependency:"legacy.proto"`,
+ `name:"optional_uint32" number:10002 label:LABEL_OPTIONAL type:TYPE_UINT32 default_value:"3200" extendee:".LegacyTestMessage"`,
+ nil, depReg,
+ ),
+ mustMakeExtensionType(
+ `package:"fizz.buzz" dependency:"legacy.proto"`,
+ `name:"optional_float" number:10003 label:LABEL_OPTIONAL type:TYPE_FLOAT default_value:"3.14159" extendee:".LegacyTestMessage"`,
+ nil, depReg,
+ ),
+ mustMakeExtensionType(
+ `package:"fizz.buzz" dependency:"legacy.proto"`,
+ `name:"optional_string" number:10004 label:LABEL_OPTIONAL type:TYPE_STRING default_value:"hello, \"world!\"\n" extendee:".LegacyTestMessage"`,
+ nil, depReg,
+ ),
+ mustMakeExtensionType(
+ `package:"fizz.buzz" dependency:"legacy.proto"`,
+ `name:"optional_bytes" number:10005 label:LABEL_OPTIONAL type:TYPE_BYTES default_value:"dead\\336\\255\\276\\357beef" extendee:".LegacyTestMessage"`,
+ nil, depReg,
+ ),
+ mustMakeExtensionType(
+ `package:"fizz.buzz" dependency:["legacy.proto", "proto2.v1.0.0-20180125-92554152/test.proto"]`,
+ `name:"optional_enum_v1" number:10006 label:LABEL_OPTIONAL type:TYPE_ENUM type_name:".google.golang.org.proto2_20180125.Message.ChildEnum" default_value:"ALPHA" extendee:".LegacyTestMessage"`,
+ proto2_20180125.Message_ChildEnum(0), depReg,
+ ),
+ mustMakeExtensionType(
+ `package:"fizz.buzz" dependency:["legacy.proto", "proto2.v1.0.0-20180125-92554152/test.proto"]`,
+ `name:"optional_message_v1" number:10007 label:LABEL_OPTIONAL type:TYPE_MESSAGE type_name:".google.golang.org.proto2_20180125.Message.ChildMessage" extendee:".LegacyTestMessage"`,
+ (*proto2_20180125.Message_ChildMessage)(nil), depReg,
+ ),
+ mustMakeExtensionType(
+ `package:"fizz.buzz" dependency:["legacy.proto", "enum2.proto"]`,
+ `name:"optional_enum_v2" number:10008 label:LABEL_OPTIONAL type:TYPE_ENUM type_name:".EnumProto2" default_value:"DEAD" extendee:".LegacyTestMessage"`,
+ EnumProto2(0), depReg,
+ ),
+ mustMakeExtensionType(
+ `package:"fizz.buzz" dependency:["legacy.proto", "enum-messages.proto"]`,
+ `name:"optional_message_v2" number:10009 label:LABEL_OPTIONAL type:TYPE_MESSAGE type_name:".EnumMessages" extendee:".LegacyTestMessage"`,
+ (*EnumMessages)(nil), depReg,
+ ),
+ mustMakeExtensionType(
+ `package:"fizz.buzz" dependency:"legacy.proto"`,
+ `name:"repeated_bool" number:10010 label:LABEL_REPEATED type:TYPE_BOOL extendee:".LegacyTestMessage"`,
+ nil, depReg,
+ ),
+ mustMakeExtensionType(
+ `package:"fizz.buzz" dependency:"legacy.proto"`,
+ `name:"repeated_int32" number:10011 label:LABEL_REPEATED type:TYPE_INT32 extendee:".LegacyTestMessage"`,
+ nil, depReg,
+ ),
+ mustMakeExtensionType(
+ `package:"fizz.buzz" dependency:"legacy.proto"`,
+ `name:"repeated_uint32" number:10012 label:LABEL_REPEATED type:TYPE_UINT32 extendee:".LegacyTestMessage"`,
+ nil, depReg,
+ ),
+ mustMakeExtensionType(
+ `package:"fizz.buzz" dependency:"legacy.proto"`,
+ `name:"repeated_float" number:10013 label:LABEL_REPEATED type:TYPE_FLOAT extendee:".LegacyTestMessage"`,
+ nil, depReg,
+ ),
+ mustMakeExtensionType(
+ `package:"fizz.buzz" dependency:"legacy.proto"`,
+ `name:"repeated_string" number:10014 label:LABEL_REPEATED type:TYPE_STRING extendee:".LegacyTestMessage"`,
+ nil, depReg,
+ ),
+ mustMakeExtensionType(
+ `package:"fizz.buzz" dependency:"legacy.proto"`,
+ `name:"repeated_bytes" number:10015 label:LABEL_REPEATED type:TYPE_BYTES extendee:".LegacyTestMessage"`,
+ nil, depReg,
+ ),
+ mustMakeExtensionType(
+ `package:"fizz.buzz" dependency:["legacy.proto", "proto2.v1.0.0-20180125-92554152/test.proto"]`,
+ `name:"repeated_enum_v1" number:10016 label:LABEL_REPEATED type:TYPE_ENUM type_name:".google.golang.org.proto2_20180125.Message.ChildEnum" extendee:".LegacyTestMessage"`,
+ proto2_20180125.Message_ChildEnum(0), depReg,
+ ),
+ mustMakeExtensionType(
+ `package:"fizz.buzz" dependency:["legacy.proto", "proto2.v1.0.0-20180125-92554152/test.proto"]`,
+ `name:"repeated_message_v1" number:10017 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".google.golang.org.proto2_20180125.Message.ChildMessage" extendee:".LegacyTestMessage"`,
+ (*proto2_20180125.Message_ChildMessage)(nil), depReg,
+ ),
+ mustMakeExtensionType(
+ `package:"fizz.buzz" dependency:["legacy.proto", "enum2.proto"]`,
+ `name:"repeated_enum_v2" number:10018 label:LABEL_REPEATED type:TYPE_ENUM type_name:".EnumProto2" extendee:".LegacyTestMessage"`,
+ EnumProto2(0), depReg,
+ ),
+ mustMakeExtensionType(
+ `package:"fizz.buzz" dependency:["legacy.proto", "enum-messages.proto"]`,
+ `name:"repeated_message_v2" number:10019 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".EnumMessages" extendee:".LegacyTestMessage"`,
+ (*EnumMessages)(nil), depReg,
+ ),
}
extensionDescs = []*piface.ExtensionDescV1{{
- ExtendedType: (*legacyTestMessage)(nil),
+ ExtendedType: (*LegacyTestMessage)(nil),
ExtensionType: (*bool)(nil),
Field: 10000,
Name: "fizz.buzz.optional_bool",
Tag: "varint,10000,opt,name=optional_bool,def=1",
+ Filename: "test.proto",
}, {
- ExtendedType: (*legacyTestMessage)(nil),
+ ExtendedType: (*LegacyTestMessage)(nil),
ExtensionType: (*int32)(nil),
Field: 10001,
Name: "fizz.buzz.optional_int32",
Tag: "varint,10001,opt,name=optional_int32,def=-12345",
+ Filename: "test.proto",
}, {
- ExtendedType: (*legacyTestMessage)(nil),
+ ExtendedType: (*LegacyTestMessage)(nil),
ExtensionType: (*uint32)(nil),
Field: 10002,
Name: "fizz.buzz.optional_uint32",
Tag: "varint,10002,opt,name=optional_uint32,def=3200",
+ Filename: "test.proto",
}, {
- ExtendedType: (*legacyTestMessage)(nil),
+ ExtendedType: (*LegacyTestMessage)(nil),
ExtensionType: (*float32)(nil),
Field: 10003,
Name: "fizz.buzz.optional_float",
Tag: "fixed32,10003,opt,name=optional_float,def=3.14159",
+ Filename: "test.proto",
}, {
- ExtendedType: (*legacyTestMessage)(nil),
+ ExtendedType: (*LegacyTestMessage)(nil),
ExtensionType: (*string)(nil),
Field: 10004,
Name: "fizz.buzz.optional_string",
Tag: "bytes,10004,opt,name=optional_string,def=hello, \"world!\"\n",
+ Filename: "test.proto",
}, {
- ExtendedType: (*legacyTestMessage)(nil),
+ 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",
+ Filename: "test.proto",
}, {
- ExtendedType: (*legacyTestMessage)(nil),
+ 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",
+ Filename: "test.proto",
}, {
- ExtendedType: (*legacyTestMessage)(nil),
+ 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",
+ Filename: "test.proto",
}, {
- ExtendedType: (*legacyTestMessage)(nil),
+ 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",
+ Filename: "test.proto",
}, {
- ExtendedType: (*legacyTestMessage)(nil),
+ ExtendedType: (*LegacyTestMessage)(nil),
ExtensionType: (*EnumMessages)(nil),
Field: 10009,
Name: "fizz.buzz.optional_message_v2",
Tag: "bytes,10009,opt,name=optional_message_v2",
+ Filename: "test.proto",
}, {
- ExtendedType: (*legacyTestMessage)(nil),
+ ExtendedType: (*LegacyTestMessage)(nil),
ExtensionType: ([]bool)(nil),
Field: 10010,
Name: "fizz.buzz.repeated_bool",
Tag: "varint,10010,rep,name=repeated_bool",
+ Filename: "test.proto",
}, {
- ExtendedType: (*legacyTestMessage)(nil),
+ ExtendedType: (*LegacyTestMessage)(nil),
ExtensionType: ([]int32)(nil),
Field: 10011,
Name: "fizz.buzz.repeated_int32",
Tag: "varint,10011,rep,name=repeated_int32",
+ Filename: "test.proto",
}, {
- ExtendedType: (*legacyTestMessage)(nil),
+ ExtendedType: (*LegacyTestMessage)(nil),
ExtensionType: ([]uint32)(nil),
Field: 10012,
Name: "fizz.buzz.repeated_uint32",
Tag: "varint,10012,rep,name=repeated_uint32",
+ Filename: "test.proto",
}, {
- ExtendedType: (*legacyTestMessage)(nil),
+ ExtendedType: (*LegacyTestMessage)(nil),
ExtensionType: ([]float32)(nil),
Field: 10013,
Name: "fizz.buzz.repeated_float",
Tag: "fixed32,10013,rep,name=repeated_float",
+ Filename: "test.proto",
}, {
- ExtendedType: (*legacyTestMessage)(nil),
+ ExtendedType: (*LegacyTestMessage)(nil),
ExtensionType: ([]string)(nil),
Field: 10014,
Name: "fizz.buzz.repeated_string",
Tag: "bytes,10014,rep,name=repeated_string",
+ Filename: "test.proto",
}, {
- ExtendedType: (*legacyTestMessage)(nil),
+ ExtendedType: (*LegacyTestMessage)(nil),
ExtensionType: ([][]byte)(nil),
Field: 10015,
Name: "fizz.buzz.repeated_bytes",
Tag: "bytes,10015,rep,name=repeated_bytes",
+ Filename: "test.proto",
}, {
- ExtendedType: (*legacyTestMessage)(nil),
+ 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",
+ Filename: "test.proto",
}, {
- ExtendedType: (*legacyTestMessage)(nil),
+ 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",
+ Filename: "test.proto",
}, {
- ExtendedType: (*legacyTestMessage)(nil),
+ ExtendedType: (*LegacyTestMessage)(nil),
ExtensionType: ([]EnumProto2)(nil),
Field: 10018,
Name: "fizz.buzz.repeated_enum_v2",
Tag: "varint,10018,rep,name=repeated_enum_v2,enum=EnumProto2",
+ Filename: "test.proto",
}, {
- ExtendedType: (*legacyTestMessage)(nil),
+ ExtendedType: (*LegacyTestMessage)(nil),
ExtensionType: ([]*EnumMessages)(nil),
Field: 10019,
Name: "fizz.buzz.repeated_message_v2",
Tag: "bytes,10019,rep,name=repeated_message_v2",
+ Filename: "test.proto",
}}
)
@@ -333,7 +340,7 @@
return x == y // pointer compare messages for object identity
})}
- m := pimpl.Export{}.MessageOf(new(legacyTestMessage))
+ m := pimpl.Export{}.MessageOf(new(LegacyTestMessage))
if n := m.Len(); n != 0 {
t.Errorf("KnownFields.Len() = %v, want 0", n)
@@ -490,13 +497,6 @@
}
return out
}),
- // TODO: Add this when ExtensionType no longer implements
- // ExtensionDescriptor.
- /*
- cmp.Transformer("", func(x pref.ExtensionType) pref.ExtensionDescriptor {
- return x.Descriptor()
- }),
- */
cmp.Transformer("", func(x pref.Descriptor) map[string]interface{} {
out := make(map[string]interface{})
v := reflect.ValueOf(x)
@@ -558,6 +558,38 @@
Enum int32
)
+func (*MessageA) Descriptor() ([]byte, []int) { return concurrentFD, []int{0} }
+func (*MessageB) Descriptor() ([]byte, []int) { return concurrentFD, []int{1} }
+func (Enum) EnumDescriptor() ([]byte, []int) { return concurrentFD, []int{0} }
+
+var concurrentFD = func() []byte {
+ b, _ := proto.Marshal(pdesc.ToFileDescriptorProto(mustMakeFileDesc(`
+ name: "concurrent.proto"
+ syntax: "proto2"
+ package: "legacy"
+ message_type: [{
+ name: "MessageA"
+ field: [
+ {name:"a1" number:1 label:LABEL_REQUIRED type:TYPE_MESSAGE type_name:".legacy.MessageA"},
+ {name:"a2" number:2 label:LABEL_REQUIRED type:TYPE_MESSAGE type_name:".legacy.MessageB"},
+ {name:"a3" number:3 label:LABEL_OPTIONAL type:TYPE_ENUM type_name:".legacy.Enum"}
+ ]
+ }, {
+ name: "MessageB"
+ field: [
+ {name:"a1" number:1 label:LABEL_REQUIRED type:TYPE_MESSAGE type_name:".legacy.MessageA"},
+ {name:"a2" number:2 label:LABEL_REQUIRED type:TYPE_MESSAGE type_name:".legacy.MessageB"},
+ {name:"a3" number:3 label:LABEL_OPTIONAL type:TYPE_ENUM type_name:".legacy.Enum"}
+ ]
+ }]
+ enum_type: [{
+ name: "Enum"
+ value: [{name:"FOO" number:500}]
+ }]
+ `, nil)))
+ return pimpl.Export{}.CompressGZIP(b)
+}()
+
// TestConcurrentInit tests that concurrent wrapping of multiple legacy types
// results in the exact same descriptor being created.
func TestConcurrentInit(t *testing.T) {
diff --git a/internal/impl/message.go b/internal/impl/message.go
index df2fcee..161f194 100644
--- a/internal/impl/message.go
+++ b/internal/impl/message.go
@@ -283,6 +283,9 @@
if fx.Type == extensionFieldsType {
fieldOffset := offsetOf(fx)
mi.extensionMap = func(p pointer) *extensionMap {
+ if p.IsNil() {
+ return (*extensionMap)(nil)
+ }
v := p.Apply(fieldOffset).AsValueOf(extensionFieldsType)
return (*extensionMap)(v.Interface().(*map[int32]ExtensionField))
}
diff --git a/internal/impl/message_test.go b/internal/impl/message_test.go
index 722d1c0..fb89a2d 100644
--- a/internal/impl/message_test.go
+++ b/internal/impl/message_test.go
@@ -11,13 +11,15 @@
"strings"
"testing"
- protoV1 "github.com/golang/protobuf/proto"
cmp "github.com/google/go-cmp/cmp"
cmpopts "github.com/google/go-cmp/cmp/cmpopts"
+ "google.golang.org/protobuf/encoding/prototext"
pimpl "google.golang.org/protobuf/internal/impl"
- ptype "google.golang.org/protobuf/internal/prototype"
scalar "google.golang.org/protobuf/internal/scalar"
+ "google.golang.org/protobuf/proto"
+ pdesc "google.golang.org/protobuf/reflect/protodesc"
pref "google.golang.org/protobuf/reflect/protoreflect"
+ "google.golang.org/protobuf/reflect/protoregistry"
"google.golang.org/protobuf/reflect/prototype"
proto2_20180125 "google.golang.org/protobuf/internal/testprotos/legacy/proto2.v1.0.0-20180125-92554152"
@@ -158,20 +160,30 @@
MyBytesA *MyString `protobuf:"22"`
}
-func mustMakeEnumDesc(t ptype.StandaloneEnum) pref.EnumDescriptor {
- ed, err := ptype.NewEnum(&t)
+func mustMakeEnumDesc(path string, syntax pref.Syntax, enumDesc string) pref.EnumDescriptor {
+ s := fmt.Sprintf(`name:%q syntax:%q enum_type:[{%s}]`, path, syntax, enumDesc)
+ pb := new(descriptorpb.FileDescriptorProto)
+ if err := prototext.Unmarshal([]byte(s), pb); err != nil {
+ panic(err)
+ }
+ fd, err := pdesc.NewFile(pb, nil)
if err != nil {
panic(err)
}
- return ed
+ return fd.Enums().Get(0)
}
-func mustMakeMessageDesc(t ptype.StandaloneMessage) pref.MessageDescriptor {
- md, err := ptype.NewMessage(&t)
+func mustMakeMessageDesc(path string, syntax pref.Syntax, fileDesc, msgDesc string, r pdesc.Resolver) pref.MessageDescriptor {
+ s := fmt.Sprintf(`name:%q syntax:%q %s message_type:[{%s}]`, path, syntax, fileDesc, msgDesc)
+ pb := new(descriptorpb.FileDescriptorProto)
+ if err := prototext.Unmarshal([]byte(s), pb); err != nil {
+ panic(err)
+ }
+ fd, err := pdesc.NewFile(pb, r)
if err != nil {
panic(err)
}
- return md
+ return fd.Messages().Get(0)
}
var V = pref.ValueOf
@@ -196,35 +208,34 @@
)
var scalarProto2Type = pimpl.MessageInfo{GoType: reflect.TypeOf(new(ScalarProto2)), PBType: &prototype.Message{
- MessageDescriptor: mustMakeMessageDesc(ptype.StandaloneMessage{
- Syntax: pref.Proto2,
- FullName: "ScalarProto2",
- Fields: []ptype.Field{
- {Name: "f1", Number: 1, Cardinality: pref.Optional, Kind: pref.BoolKind, Default: V(bool(true))},
- {Name: "f2", Number: 2, Cardinality: pref.Optional, Kind: pref.Int32Kind, Default: V(int32(2))},
- {Name: "f3", Number: 3, Cardinality: pref.Optional, Kind: pref.Int64Kind, Default: V(int64(3))},
- {Name: "f4", Number: 4, Cardinality: pref.Optional, Kind: pref.Uint32Kind, Default: V(uint32(4))},
- {Name: "f5", Number: 5, Cardinality: pref.Optional, Kind: pref.Uint64Kind, Default: V(uint64(5))},
- {Name: "f6", Number: 6, Cardinality: pref.Optional, Kind: pref.FloatKind, Default: V(float32(6))},
- {Name: "f7", Number: 7, Cardinality: pref.Optional, Kind: pref.DoubleKind, Default: V(float64(7))},
- {Name: "f8", Number: 8, Cardinality: pref.Optional, Kind: pref.StringKind, Default: V(string("8"))},
- {Name: "f9", Number: 9, Cardinality: pref.Optional, Kind: pref.StringKind, Default: V(string("9"))},
- {Name: "f10", Number: 10, Cardinality: pref.Optional, Kind: pref.BytesKind, Default: V([]byte("10"))},
- {Name: "f11", Number: 11, Cardinality: pref.Optional, Kind: pref.BytesKind, Default: V([]byte("11"))},
+ MessageDescriptor: mustMakeMessageDesc("scalar2.proto", pref.Proto2, "", `
+ name: "ScalarProto2"
+ field: [
+ {name:"f1" number:1 label:LABEL_OPTIONAL type:TYPE_BOOL default_value:"true"},
+ {name:"f2" number:2 label:LABEL_OPTIONAL type:TYPE_INT32 default_value:"2"},
+ {name:"f3" number:3 label:LABEL_OPTIONAL type:TYPE_INT64 default_value:"3"},
+ {name:"f4" number:4 label:LABEL_OPTIONAL type:TYPE_UINT32 default_value:"4"},
+ {name:"f5" number:5 label:LABEL_OPTIONAL type:TYPE_UINT64 default_value:"5"},
+ {name:"f6" number:6 label:LABEL_OPTIONAL type:TYPE_FLOAT default_value:"6"},
+ {name:"f7" number:7 label:LABEL_OPTIONAL type:TYPE_DOUBLE default_value:"7"},
+ {name:"f8" number:8 label:LABEL_OPTIONAL type:TYPE_STRING default_value:"8"},
+ {name:"f9" number:9 label:LABEL_OPTIONAL type:TYPE_STRING default_value:"9"},
+ {name:"f10" number:10 label:LABEL_OPTIONAL type:TYPE_BYTES default_value:"10"},
+ {name:"f11" number:11 label:LABEL_OPTIONAL type:TYPE_BYTES default_value:"11"},
- {Name: "f12", Number: 12, Cardinality: pref.Optional, Kind: pref.BoolKind, Default: V(bool(true))},
- {Name: "f13", Number: 13, Cardinality: pref.Optional, Kind: pref.Int32Kind, Default: V(int32(13))},
- {Name: "f14", Number: 14, Cardinality: pref.Optional, Kind: pref.Int64Kind, Default: V(int64(14))},
- {Name: "f15", Number: 15, Cardinality: pref.Optional, Kind: pref.Uint32Kind, Default: V(uint32(15))},
- {Name: "f16", Number: 16, Cardinality: pref.Optional, Kind: pref.Uint64Kind, Default: V(uint64(16))},
- {Name: "f17", Number: 17, Cardinality: pref.Optional, Kind: pref.FloatKind, Default: V(float32(17))},
- {Name: "f18", Number: 18, Cardinality: pref.Optional, Kind: pref.DoubleKind, Default: V(float64(18))},
- {Name: "f19", Number: 19, Cardinality: pref.Optional, Kind: pref.StringKind, Default: V(string("19"))},
- {Name: "f20", Number: 20, Cardinality: pref.Optional, Kind: pref.StringKind, Default: V(string("20"))},
- {Name: "f21", Number: 21, Cardinality: pref.Optional, Kind: pref.BytesKind, Default: V([]byte("21"))},
- {Name: "f22", Number: 22, Cardinality: pref.Optional, Kind: pref.BytesKind, Default: V([]byte("22"))},
- },
- }),
+ {name:"f12" number:12 label:LABEL_OPTIONAL type:TYPE_BOOL default_value:"true"},
+ {name:"f13" number:13 label:LABEL_OPTIONAL type:TYPE_INT32 default_value:"13"},
+ {name:"f14" number:14 label:LABEL_OPTIONAL type:TYPE_INT64 default_value:"14"},
+ {name:"f15" number:15 label:LABEL_OPTIONAL type:TYPE_UINT32 default_value:"15"},
+ {name:"f16" number:16 label:LABEL_OPTIONAL type:TYPE_UINT64 default_value:"16"},
+ {name:"f17" number:17 label:LABEL_OPTIONAL type:TYPE_FLOAT default_value:"17"},
+ {name:"f18" number:18 label:LABEL_OPTIONAL type:TYPE_DOUBLE default_value:"18"},
+ {name:"f19" number:19 label:LABEL_OPTIONAL type:TYPE_STRING default_value:"19"},
+ {name:"f20" number:20 label:LABEL_OPTIONAL type:TYPE_STRING default_value:"20"},
+ {name:"f21" number:21 label:LABEL_OPTIONAL type:TYPE_BYTES default_value:"21"},
+ {name:"f22" number:22 label:LABEL_OPTIONAL type:TYPE_BYTES default_value:"22"}
+ ]
+ `, nil),
NewMessage: func() pref.Message {
return pref.ProtoMessage(new(ScalarProto2)).ProtoReflect()
},
@@ -298,35 +309,34 @@
}
var scalarProto3Type = pimpl.MessageInfo{GoType: reflect.TypeOf(new(ScalarProto3)), PBType: &prototype.Message{
- MessageDescriptor: mustMakeMessageDesc(ptype.StandaloneMessage{
- Syntax: pref.Proto3,
- FullName: "ScalarProto3",
- Fields: []ptype.Field{
- {Name: "f1", Number: 1, Cardinality: pref.Optional, Kind: pref.BoolKind},
- {Name: "f2", Number: 2, Cardinality: pref.Optional, Kind: pref.Int32Kind},
- {Name: "f3", Number: 3, Cardinality: pref.Optional, Kind: pref.Int64Kind},
- {Name: "f4", Number: 4, Cardinality: pref.Optional, Kind: pref.Uint32Kind},
- {Name: "f5", Number: 5, Cardinality: pref.Optional, Kind: pref.Uint64Kind},
- {Name: "f6", Number: 6, Cardinality: pref.Optional, Kind: pref.FloatKind},
- {Name: "f7", Number: 7, Cardinality: pref.Optional, Kind: pref.DoubleKind},
- {Name: "f8", Number: 8, Cardinality: pref.Optional, Kind: pref.StringKind},
- {Name: "f9", Number: 9, Cardinality: pref.Optional, Kind: pref.StringKind},
- {Name: "f10", Number: 10, Cardinality: pref.Optional, Kind: pref.BytesKind},
- {Name: "f11", Number: 11, Cardinality: pref.Optional, Kind: pref.BytesKind},
+ MessageDescriptor: mustMakeMessageDesc("scalar3.proto", pref.Proto3, "", `
+ name: "ScalarProto3"
+ field: [
+ {name:"f1" number:1 label:LABEL_OPTIONAL type:TYPE_BOOL},
+ {name:"f2" number:2 label:LABEL_OPTIONAL type:TYPE_INT32},
+ {name:"f3" number:3 label:LABEL_OPTIONAL type:TYPE_INT64},
+ {name:"f4" number:4 label:LABEL_OPTIONAL type:TYPE_UINT32},
+ {name:"f5" number:5 label:LABEL_OPTIONAL type:TYPE_UINT64},
+ {name:"f6" number:6 label:LABEL_OPTIONAL type:TYPE_FLOAT},
+ {name:"f7" number:7 label:LABEL_OPTIONAL type:TYPE_DOUBLE},
+ {name:"f8" number:8 label:LABEL_OPTIONAL type:TYPE_STRING},
+ {name:"f9" number:9 label:LABEL_OPTIONAL type:TYPE_STRING},
+ {name:"f10" number:10 label:LABEL_OPTIONAL type:TYPE_BYTES},
+ {name:"f11" number:11 label:LABEL_OPTIONAL type:TYPE_BYTES},
- {Name: "f12", Number: 12, Cardinality: pref.Optional, Kind: pref.BoolKind},
- {Name: "f13", Number: 13, Cardinality: pref.Optional, Kind: pref.Int32Kind},
- {Name: "f14", Number: 14, Cardinality: pref.Optional, Kind: pref.Int64Kind},
- {Name: "f15", Number: 15, Cardinality: pref.Optional, Kind: pref.Uint32Kind},
- {Name: "f16", Number: 16, Cardinality: pref.Optional, Kind: pref.Uint64Kind},
- {Name: "f17", Number: 17, Cardinality: pref.Optional, Kind: pref.FloatKind},
- {Name: "f18", Number: 18, Cardinality: pref.Optional, Kind: pref.DoubleKind},
- {Name: "f19", Number: 19, Cardinality: pref.Optional, Kind: pref.StringKind},
- {Name: "f20", Number: 20, Cardinality: pref.Optional, Kind: pref.StringKind},
- {Name: "f21", Number: 21, Cardinality: pref.Optional, Kind: pref.BytesKind},
- {Name: "f22", Number: 22, Cardinality: pref.Optional, Kind: pref.BytesKind},
- },
- }),
+ {name:"f12" number:12 label:LABEL_OPTIONAL type:TYPE_BOOL},
+ {name:"f13" number:13 label:LABEL_OPTIONAL type:TYPE_INT32},
+ {name:"f14" number:14 label:LABEL_OPTIONAL type:TYPE_INT64},
+ {name:"f15" number:15 label:LABEL_OPTIONAL type:TYPE_UINT32},
+ {name:"f16" number:16 label:LABEL_OPTIONAL type:TYPE_UINT64},
+ {name:"f17" number:17 label:LABEL_OPTIONAL type:TYPE_FLOAT},
+ {name:"f18" number:18 label:LABEL_OPTIONAL type:TYPE_DOUBLE},
+ {name:"f19" number:19 label:LABEL_OPTIONAL type:TYPE_STRING},
+ {name:"f20" number:20 label:LABEL_OPTIONAL type:TYPE_STRING},
+ {name:"f21" number:21 label:LABEL_OPTIONAL type:TYPE_BYTES},
+ {name:"f22" number:22 label:LABEL_OPTIONAL type:TYPE_BYTES}
+ ]
+ `, nil),
NewMessage: func() pref.Message {
return pref.ProtoMessage(new(ScalarProto3)).ProtoReflect()
},
@@ -418,33 +428,32 @@
}
var listScalarsType = pimpl.MessageInfo{GoType: reflect.TypeOf(new(ListScalars)), PBType: &prototype.Message{
- MessageDescriptor: mustMakeMessageDesc(ptype.StandaloneMessage{
- Syntax: pref.Proto2,
- FullName: "ListScalars",
- Fields: []ptype.Field{
- {Name: "f1", Number: 1, Cardinality: pref.Repeated, Kind: pref.BoolKind},
- {Name: "f2", Number: 2, Cardinality: pref.Repeated, Kind: pref.Int32Kind},
- {Name: "f3", Number: 3, Cardinality: pref.Repeated, Kind: pref.Int64Kind},
- {Name: "f4", Number: 4, Cardinality: pref.Repeated, Kind: pref.Uint32Kind},
- {Name: "f5", Number: 5, Cardinality: pref.Repeated, Kind: pref.Uint64Kind},
- {Name: "f6", Number: 6, Cardinality: pref.Repeated, Kind: pref.FloatKind},
- {Name: "f7", Number: 7, Cardinality: pref.Repeated, Kind: pref.DoubleKind},
- {Name: "f8", Number: 8, Cardinality: pref.Repeated, Kind: pref.StringKind},
- {Name: "f9", Number: 9, Cardinality: pref.Repeated, Kind: pref.StringKind},
- {Name: "f10", Number: 10, Cardinality: pref.Repeated, Kind: pref.BytesKind},
- {Name: "f11", Number: 11, Cardinality: pref.Repeated, Kind: pref.BytesKind},
+ MessageDescriptor: mustMakeMessageDesc("list-scalars.proto", pref.Proto2, "", `
+ name: "ListScalars"
+ field: [
+ {name:"f1" number:1 label:LABEL_REPEATED type:TYPE_BOOL},
+ {name:"f2" number:2 label:LABEL_REPEATED type:TYPE_INT32},
+ {name:"f3" number:3 label:LABEL_REPEATED type:TYPE_INT64},
+ {name:"f4" number:4 label:LABEL_REPEATED type:TYPE_UINT32},
+ {name:"f5" number:5 label:LABEL_REPEATED type:TYPE_UINT64},
+ {name:"f6" number:6 label:LABEL_REPEATED type:TYPE_FLOAT},
+ {name:"f7" number:7 label:LABEL_REPEATED type:TYPE_DOUBLE},
+ {name:"f8" number:8 label:LABEL_REPEATED type:TYPE_STRING},
+ {name:"f9" number:9 label:LABEL_REPEATED type:TYPE_STRING},
+ {name:"f10" number:10 label:LABEL_REPEATED type:TYPE_BYTES},
+ {name:"f11" number:11 label:LABEL_REPEATED type:TYPE_BYTES},
- {Name: "f12", Number: 12, Cardinality: pref.Repeated, Kind: pref.StringKind},
- {Name: "f13", Number: 13, Cardinality: pref.Repeated, Kind: pref.StringKind},
- {Name: "f14", Number: 14, Cardinality: pref.Repeated, Kind: pref.BytesKind},
- {Name: "f15", Number: 15, Cardinality: pref.Repeated, Kind: pref.BytesKind},
+ {name:"f12" number:12 label:LABEL_REPEATED type:TYPE_STRING},
+ {name:"f13" number:13 label:LABEL_REPEATED type:TYPE_STRING},
+ {name:"f14" number:14 label:LABEL_REPEATED type:TYPE_BYTES},
+ {name:"f15" number:15 label:LABEL_REPEATED type:TYPE_BYTES},
- {Name: "f16", Number: 16, Cardinality: pref.Repeated, Kind: pref.StringKind},
- {Name: "f17", Number: 17, Cardinality: pref.Repeated, Kind: pref.StringKind},
- {Name: "f18", Number: 18, Cardinality: pref.Repeated, Kind: pref.BytesKind},
- {Name: "f19", Number: 19, Cardinality: pref.Repeated, Kind: pref.BytesKind},
- },
- }),
+ {name:"f16" number:16 label:LABEL_REPEATED type:TYPE_STRING},
+ {name:"f17" number:17 label:LABEL_REPEATED type:TYPE_STRING},
+ {name:"f18" number:18 label:LABEL_REPEATED type:TYPE_BYTES},
+ {name:"f19" number:19 label:LABEL_REPEATED type:TYPE_BYTES}
+ ]
+ `, nil),
NewMessage: func() pref.Message {
return pref.ProtoMessage(new(ListScalars)).ProtoReflect()
},
@@ -575,60 +584,70 @@
MyBytes4 MapStrings `protobuf:"25"`
}
-func mustMakeMapEntry(n pref.FieldNumber, keyKind, valKind pref.Kind) ptype.Field {
- return ptype.Field{
- Name: pref.Name(fmt.Sprintf("f%d", n)),
- Number: n,
- Cardinality: pref.Repeated,
- Kind: pref.MessageKind,
- MessageType: mustMakeMessageDesc(ptype.StandaloneMessage{
- Syntax: pref.Proto2,
- FullName: pref.FullName(fmt.Sprintf("MapScalars.F%dEntry", n)),
- Fields: []ptype.Field{
- {Name: "key", Number: 1, Cardinality: pref.Optional, Kind: keyKind},
- {Name: "value", Number: 2, Cardinality: pref.Optional, Kind: valKind},
- },
- Options: &descriptorpb.MessageOptions{MapEntry: scalar.Bool(true)},
- IsMapEntry: true,
- }),
- }
-}
-
var mapScalarsType = pimpl.MessageInfo{GoType: reflect.TypeOf(new(MapScalars)), PBType: &prototype.Message{
- MessageDescriptor: mustMakeMessageDesc(ptype.StandaloneMessage{
- Syntax: pref.Proto2,
- FullName: "MapScalars",
- Fields: []ptype.Field{
- mustMakeMapEntry(1, pref.BoolKind, pref.StringKind),
- mustMakeMapEntry(2, pref.Int32Kind, pref.StringKind),
- mustMakeMapEntry(3, pref.Int64Kind, pref.StringKind),
- mustMakeMapEntry(4, pref.Uint32Kind, pref.StringKind),
- mustMakeMapEntry(5, pref.Uint64Kind, pref.StringKind),
- mustMakeMapEntry(6, pref.StringKind, pref.StringKind),
+ MessageDescriptor: mustMakeMessageDesc("map-scalars.proto", pref.Proto2, "", `
+ name: "MapScalars"
+ field: [
+ {name:"f1" number:1 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F1Entry"},
+ {name:"f2" number:2 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F2Entry"},
+ {name:"f3" number:3 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F3Entry"},
+ {name:"f4" number:4 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F4Entry"},
+ {name:"f5" number:5 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F5Entry"},
+ {name:"f6" number:6 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F6Entry"},
- mustMakeMapEntry(7, pref.StringKind, pref.BoolKind),
- mustMakeMapEntry(8, pref.StringKind, pref.Int32Kind),
- mustMakeMapEntry(9, pref.StringKind, pref.Int64Kind),
- mustMakeMapEntry(10, pref.StringKind, pref.Uint32Kind),
- mustMakeMapEntry(11, pref.StringKind, pref.Uint64Kind),
- mustMakeMapEntry(12, pref.StringKind, pref.FloatKind),
- mustMakeMapEntry(13, pref.StringKind, pref.DoubleKind),
- mustMakeMapEntry(14, pref.StringKind, pref.StringKind),
- mustMakeMapEntry(15, pref.StringKind, pref.StringKind),
- mustMakeMapEntry(16, pref.StringKind, pref.BytesKind),
- mustMakeMapEntry(17, pref.StringKind, pref.BytesKind),
+ {name:"f7" number:7 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F7Entry"},
+ {name:"f8" number:8 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F8Entry"},
+ {name:"f9" number:9 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F9Entry"},
+ {name:"f10" number:10 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F10Entry"},
+ {name:"f11" number:11 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F11Entry"},
+ {name:"f12" number:12 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F12Entry"},
+ {name:"f13" number:13 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F13Entry"},
+ {name:"f14" number:14 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F14Entry"},
+ {name:"f15" number:15 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F15Entry"},
+ {name:"f16" number:16 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F16Entry"},
+ {name:"f17" number:17 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F17Entry"},
- mustMakeMapEntry(18, pref.StringKind, pref.StringKind),
- mustMakeMapEntry(19, pref.StringKind, pref.StringKind),
- mustMakeMapEntry(20, pref.StringKind, pref.BytesKind),
- mustMakeMapEntry(21, pref.StringKind, pref.BytesKind),
+ {name:"f18" number:18 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F18Entry"},
+ {name:"f19" number:19 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F19Entry"},
+ {name:"f20" number:20 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F20Entry"},
+ {name:"f21" number:21 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F21Entry"},
- mustMakeMapEntry(22, pref.StringKind, pref.StringKind),
- mustMakeMapEntry(23, pref.StringKind, pref.StringKind),
- mustMakeMapEntry(24, pref.StringKind, pref.BytesKind),
- mustMakeMapEntry(25, pref.StringKind, pref.BytesKind),
- },
- }),
+ {name:"f22" number:22 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F22Entry"},
+ {name:"f23" number:23 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F23Entry"},
+ {name:"f24" number:24 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F24Entry"},
+ {name:"f25" number:25 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".MapScalars.F25Entry"}
+ ]
+ nested_type: [
+ {name:"F1Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_BOOL}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_STRING}] options:{map_entry:true}},
+ {name:"F2Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_INT32}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_STRING}] options:{map_entry:true}},
+ {name:"F3Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_INT64}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_STRING}] options:{map_entry:true}},
+ {name:"F4Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_UINT32}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_STRING}] options:{map_entry:true}},
+ {name:"F5Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_UINT64}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_STRING}] options:{map_entry:true}},
+ {name:"F6Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_STRING}] options:{map_entry:true}},
+
+ {name:"F7Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_BOOL}] options:{map_entry:true}},
+ {name:"F8Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_INT32}] options:{map_entry:true}},
+ {name:"F9Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_INT64}] options:{map_entry:true}},
+ {name:"F10Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_UINT32}] options:{map_entry:true}},
+ {name:"F11Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_UINT64}] options:{map_entry:true}},
+ {name:"F12Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_FLOAT}] options:{map_entry:true}},
+ {name:"F13Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_DOUBLE}] options:{map_entry:true}},
+ {name:"F14Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_STRING}] options:{map_entry:true}},
+ {name:"F15Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_STRING}] options:{map_entry:true}},
+ {name:"F16Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_BYTES}] options:{map_entry:true}},
+ {name:"F17Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_BYTES}] options:{map_entry:true}},
+
+ {name:"F18Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_STRING}] options:{map_entry:true}},
+ {name:"F19Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_STRING}] options:{map_entry:true}},
+ {name:"F20Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_BYTES}] options:{map_entry:true}},
+ {name:"F21Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_BYTES}] options:{map_entry:true}},
+
+ {name:"F22Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_STRING}] options:{map_entry:true}},
+ {name:"F23Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_STRING}] options:{map_entry:true}},
+ {name:"F24Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_BYTES}] options:{map_entry:true}},
+ {name:"F25Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_BYTES}] options:{map_entry:true}}
+ ]
+ `, nil),
NewMessage: func() pref.Message {
return pref.ProtoMessage(new(MapScalars)).ProtoReflect()
},
@@ -760,26 +779,25 @@
}
var oneofScalarsType = pimpl.MessageInfo{GoType: reflect.TypeOf(new(OneofScalars)), PBType: &prototype.Message{
- MessageDescriptor: mustMakeMessageDesc(ptype.StandaloneMessage{
- Syntax: pref.Proto2,
- FullName: "OneofScalars",
- Fields: []ptype.Field{
- {Name: "f1", Number: 1, Cardinality: pref.Optional, Kind: pref.BoolKind, Default: V(bool(true)), OneofName: "union"},
- {Name: "f2", Number: 2, Cardinality: pref.Optional, Kind: pref.Int32Kind, Default: V(int32(2)), OneofName: "union"},
- {Name: "f3", Number: 3, Cardinality: pref.Optional, Kind: pref.Int64Kind, Default: V(int64(3)), OneofName: "union"},
- {Name: "f4", Number: 4, Cardinality: pref.Optional, Kind: pref.Uint32Kind, Default: V(uint32(4)), OneofName: "union"},
- {Name: "f5", Number: 5, Cardinality: pref.Optional, Kind: pref.Uint64Kind, Default: V(uint64(5)), OneofName: "union"},
- {Name: "f6", Number: 6, Cardinality: pref.Optional, Kind: pref.FloatKind, Default: V(float32(6)), OneofName: "union"},
- {Name: "f7", Number: 7, Cardinality: pref.Optional, Kind: pref.DoubleKind, Default: V(float64(7)), OneofName: "union"},
- {Name: "f8", Number: 8, Cardinality: pref.Optional, Kind: pref.StringKind, Default: V(string("8")), OneofName: "union"},
- {Name: "f9", Number: 9, Cardinality: pref.Optional, Kind: pref.StringKind, Default: V(string("9")), OneofName: "union"},
- {Name: "f10", Number: 10, Cardinality: pref.Optional, Kind: pref.StringKind, Default: V(string("10")), OneofName: "union"},
- {Name: "f11", Number: 11, Cardinality: pref.Optional, Kind: pref.BytesKind, Default: V([]byte("11")), OneofName: "union"},
- {Name: "f12", Number: 12, Cardinality: pref.Optional, Kind: pref.BytesKind, Default: V([]byte("12")), OneofName: "union"},
- {Name: "f13", Number: 13, Cardinality: pref.Optional, Kind: pref.BytesKind, Default: V([]byte("13")), OneofName: "union"},
- },
- Oneofs: []ptype.Oneof{{Name: "union"}},
- }),
+ MessageDescriptor: mustMakeMessageDesc("oneof-scalars.proto", pref.Proto2, "", `
+ name: "OneofScalars"
+ field: [
+ {name:"f1" number:1 label:LABEL_OPTIONAL type:TYPE_BOOL default_value:"true" oneof_index:0},
+ {name:"f2" number:2 label:LABEL_OPTIONAL type:TYPE_INT32 default_value:"2" oneof_index:0},
+ {name:"f3" number:3 label:LABEL_OPTIONAL type:TYPE_INT64 default_value:"3" oneof_index:0},
+ {name:"f4" number:4 label:LABEL_OPTIONAL type:TYPE_UINT32 default_value:"4" oneof_index:0},
+ {name:"f5" number:5 label:LABEL_OPTIONAL type:TYPE_UINT64 default_value:"5" oneof_index:0},
+ {name:"f6" number:6 label:LABEL_OPTIONAL type:TYPE_FLOAT default_value:"6" oneof_index:0},
+ {name:"f7" number:7 label:LABEL_OPTIONAL type:TYPE_DOUBLE default_value:"7" oneof_index:0},
+ {name:"f8" number:8 label:LABEL_OPTIONAL type:TYPE_STRING default_value:"8" oneof_index:0},
+ {name:"f9" number:9 label:LABEL_OPTIONAL type:TYPE_STRING default_value:"9" oneof_index:0},
+ {name:"f10" number:10 label:LABEL_OPTIONAL type:TYPE_STRING default_value:"10" oneof_index:0},
+ {name:"f11" number:11 label:LABEL_OPTIONAL type:TYPE_BYTES default_value:"11" oneof_index:0},
+ {name:"f12" number:12 label:LABEL_OPTIONAL type:TYPE_BYTES default_value:"12" oneof_index:0},
+ {name:"f13" number:13 label:LABEL_OPTIONAL type:TYPE_BYTES default_value:"13" oneof_index:0}
+ ]
+ oneof_decl: [{name:"union"}]
+ `, nil),
NewMessage: func() pref.Message {
return pref.ProtoMessage(new(OneofScalars)).ProtoReflect()
},
@@ -923,11 +941,10 @@
type EnumProto2 int32
var enumProto2Type = &prototype.Enum{
- EnumDescriptor: mustMakeEnumDesc(ptype.StandaloneEnum{
- Syntax: pref.Proto2,
- FullName: "EnumProto2",
- Values: []ptype.EnumValue{{Name: "DEAD", Number: 0xdead}, {Name: "BEEF", Number: 0xbeef}},
- }),
+ EnumDescriptor: mustMakeEnumDesc("enum2.proto", pref.Proto2, `
+ name: "EnumProto2"
+ value: [{name:"DEAD" number:0xdead}, {name:"BEEF" number:0xbeef}]
+ `),
NewEnum: func(n pref.EnumNumber) pref.Enum {
return EnumProto2(n)
},
@@ -940,11 +957,10 @@
type EnumProto3 int32
var enumProto3Type = &prototype.Enum{
- EnumDescriptor: mustMakeEnumDesc(ptype.StandaloneEnum{
- Syntax: pref.Proto3,
- FullName: "EnumProto3",
- Values: []ptype.EnumValue{{Name: "ALPHA", Number: 0}, {Name: "BRAVO", Number: 1}},
- }),
+ EnumDescriptor: mustMakeEnumDesc("enum3.proto", pref.Proto3, `
+ name: "EnumProto3",
+ value: [{name:"ALPHA" number:0}, {name:"BRAVO" number:1}]
+ `),
NewEnum: func(n pref.EnumNumber) pref.Enum {
return EnumProto3(n)
},
@@ -967,52 +983,41 @@
}
var enumMessagesType = pimpl.MessageInfo{GoType: reflect.TypeOf(new(EnumMessages)), PBType: &prototype.Message{
- MessageDescriptor: 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.Descriptor()},
- {Name: "f2", Number: 2, Cardinality: pref.Optional, Kind: pref.EnumKind, Default: V("BRAVO"), EnumType: enumProto3Type.Descriptor()},
- {Name: "f3", Number: 3, Cardinality: pref.Optional, Kind: pref.MessageKind, MessageType: pimpl.Export{}.MessageDescriptorOf(new(proto2_20180125.Message))},
- {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.Descriptor()},
- {Name: "f6", Number: 6, Cardinality: pref.Repeated, Kind: pref.MessageKind, MessageType: scalarProto2Type.PBType.Descriptor()},
- {Name: "f7", Number: 7, Cardinality: pref.Repeated, Kind: pref.MessageKind, MessageType: enumMapDesc},
- {Name: "f8", Number: 8, Cardinality: pref.Repeated, Kind: pref.MessageKind, MessageType: messageMapDesc},
- {Name: "f9", Number: 9, Cardinality: pref.Optional, Kind: pref.EnumKind, Default: V("BEEF"), OneofName: "union", EnumType: enumProto2Type.Descriptor()},
- {Name: "f10", Number: 10, Cardinality: pref.Optional, Kind: pref.EnumKind, Default: V("BRAVO"), OneofName: "union", EnumType: enumProto3Type.Descriptor()},
- {Name: "f11", Number: 11, Cardinality: pref.Optional, Kind: pref.MessageKind, OneofName: "union", MessageType: scalarProto2Type.PBType.Descriptor()},
- {Name: "f12", Number: 12, Cardinality: pref.Optional, Kind: pref.MessageKind, OneofName: "union", MessageType: scalarProto3Type.PBType.Descriptor()},
- },
- Oneofs: []ptype.Oneof{{Name: "union"}},
- }),
+ MessageDescriptor: mustMakeMessageDesc("enum-messages.proto", pref.Proto2, `
+ dependency: ["enum2.proto", "enum3.proto", "scalar2.proto", "scalar3.proto", "proto2.v1.0.0-20180125-92554152/test.proto"]
+ `, `
+ name: "EnumMessages"
+ field: [
+ {name:"f1" number:1 label:LABEL_OPTIONAL type:TYPE_ENUM type_name:".EnumProto2" default_value:"BEEF"},
+ {name:"f2" number:2 label:LABEL_OPTIONAL type:TYPE_ENUM type_name:".EnumProto3" default_value:"BRAVO"},
+ {name:"f3" number:3 label:LABEL_OPTIONAL type:TYPE_MESSAGE type_Name:".google.golang.org.proto2_20180125.Message"},
+ {name:"f4" number:4 label:LABEL_OPTIONAL type:TYPE_MESSAGE type_Name:".EnumMessages"},
+ {name:"f5" number:5 label:LABEL_REPEATED type:TYPE_ENUM type_name:".EnumProto2"},
+ {name:"f6" number:6 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".ScalarProto2"},
+ {name:"f7" number:7 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".EnumMessages.F7Entry"},
+ {name:"f8" number:8 label:LABEL_REPEATED type:TYPE_MESSAGE type_name:".EnumMessages.F8Entry"},
+ {name:"f9" number:9 label:LABEL_OPTIONAL type:TYPE_ENUM type_name:".EnumProto2" oneof_index:0 default_value:"BEEF"},
+ {name:"f10" number:10 label:LABEL_OPTIONAL type:TYPE_ENUM type_name:".EnumProto3" oneof_index:0 default_value:"BRAVO"},
+ {name:"f11" number:11 label:LABEL_OPTIONAL type:TYPE_MESSAGE type_name:".ScalarProto2" oneof_index:0},
+ {name:"f12" number:12 label:LABEL_OPTIONAL type:TYPE_MESSAGE type_name:".ScalarProto3" oneof_index:0}
+ ]
+ oneof_decl: [{name:"union"}]
+ nested_type: [
+ {name:"F7Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_ENUM type_name:".EnumProto3"}] options:{map_entry:true}},
+ {name:"F8Entry" field:[{name:"key" number:1 label:LABEL_OPTIONAL type:TYPE_STRING}, {name:"value" number:2 label:LABEL_OPTIONAL type:TYPE_MESSAGE type_name:".ScalarProto3"}] options:{map_entry:true}}
+ ]
+ `, protoregistry.NewFiles(
+ EnumProto2(0).Descriptor().ParentFile(),
+ EnumProto3(0).Descriptor().ParentFile(),
+ ((*ScalarProto2)(nil)).ProtoReflect().Descriptor().ParentFile(),
+ ((*ScalarProto3)(nil)).ProtoReflect().Descriptor().ParentFile(),
+ pimpl.Export{}.MessageDescriptorOf((*proto2_20180125.Message)(nil)).ParentFile(),
+ )),
NewMessage: func() pref.Message {
return pref.ProtoMessage(new(EnumMessages)).ProtoReflect()
},
}}
-var enumMapDesc = mustMakeMessageDesc(ptype.StandaloneMessage{
- Syntax: pref.Proto2,
- FullName: "EnumMessages.F7Entry",
- Fields: []ptype.Field{
- {Name: "key", Number: 1, Cardinality: pref.Optional, Kind: pref.StringKind},
- {Name: "value", Number: 2, Cardinality: pref.Optional, Kind: pref.EnumKind, EnumType: enumProto3Type.Descriptor()},
- },
- Options: &descriptorpb.MessageOptions{MapEntry: scalar.Bool(true)},
- IsMapEntry: true,
-})
-
-var messageMapDesc = mustMakeMessageDesc(ptype.StandaloneMessage{
- Syntax: pref.Proto2,
- FullName: "EnumMessages.F8Entry",
- Fields: []ptype.Field{
- {Name: "key", Number: 1, Cardinality: pref.Optional, Kind: pref.StringKind},
- {Name: "value", Number: 2, Cardinality: pref.Optional, Kind: pref.MessageKind, MessageType: scalarProto3Type.PBType.Descriptor()},
- },
- Options: &descriptorpb.MessageOptions{MapEntry: scalar.Bool(true)},
- IsMapEntry: true,
-})
-
func (m *EnumMessages) ProtoReflect() pref.Message { return enumMessagesType.MessageOf(m) }
func (*EnumMessages) XXX_OneofWrappers() []interface{} {
@@ -1161,7 +1166,9 @@
var cmpOpts = cmp.Options{
cmp.Comparer(func(x, y *proto2_20180125.Message) bool {
- return protoV1.Equal(x, y)
+ mx := pimpl.Export{}.MessageOf(x).Interface()
+ my := pimpl.Export{}.MessageOf(y).Interface()
+ return proto.Equal(mx, my)
}),
cmp.Transformer("UnwrapValue", func(pv pref.Value) interface{} {
switch v := pv.Interface().(type) {