mirror/protobuf-go
1
0
Fork 0
mirror of https://github.com/protocolbuffers/protobuf-go.git synced 2025-04-17 02:42:35 +00:00
Code Issues Packages Projects Releases Wiki Activity

all: remove duplicate imports

Browse Source 
protoreflect (as pref) and protoiface (as piface) are imported
duplicates in some files.
Respect package name, remove unnecessary aliased import statements.

Change-Id: Ie9897f17a50d19a462035964e366af72afed0e4d
Reviewed-on: https://go-review.googlesource.com/c/protobuf/+/405694
Reviewed-by: Kirill Kolyshkin <kolyshkin@gmail.com>
Reviewed-by: Lasse Folger <lassefolger@google.com>
Reviewed-by: Damien Neil <dneil@google.com>
This commit is contained in:
Koichi Shiraishi 2022-05-11 22:50:14 +09:00 committed by Damien Neil
parent 11ec34fe79
commit e62d8edb75
12 changed files with 393 additions and 396 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

51
encoding/protojson/encode.go
View File

@ -18,7 +18,6 @@ import (
"google.golang.org/protobuf/internal/pragma"
"google.golang.org/protobuf/proto"
"google.golang.org/protobuf/reflect/protoreflect"
pref "google.golang.org/protobuf/reflect/protoreflect"
"google.golang.org/protobuf/reflect/protoregistry"
)
@ -164,8 +163,8 @@ type typeURLFieldRanger struct {
typeURL string
}
func (m typeURLFieldRanger) Range(f func(pref.FieldDescriptor, pref.Value) bool) {
if !f(typeFieldDesc, pref.ValueOfString(m.typeURL)) {
func (m typeURLFieldRanger) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
if !f(typeFieldDesc, protoreflect.ValueOfString(m.typeURL)) {
return
}
m.FieldRanger.Range(f)
@ -173,9 +172,9 @@ func (m typeURLFieldRanger) Range(f func(pref.FieldDescriptor, pref.Value) bool)
// unpopulatedFieldRanger wraps a protoreflect.Message and modifies its Range
// method to additionally iterate over unpopulated fields.
type unpopulatedFieldRanger struct{ pref.Message }
type unpopulatedFieldRanger struct{ protoreflect.Message }
func (m unpopulatedFieldRanger) Range(f func(pref.FieldDescriptor, pref.Value) bool) {
func (m unpopulatedFieldRanger) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
fds := m.Descriptor().Fields()
for i := 0; i < fds.Len(); i++ {
fd := fds.Get(i)
@ -184,10 +183,10 @@ func (m unpopulatedFieldRanger) Range(f func(pref.FieldDescriptor, pref.Value) b
}
v := m.Get(fd)
isProto2Scalar := fd.Syntax() == pref.Proto2 && fd.Default().IsValid()
isSingularMessage := fd.Cardinality() != pref.Repeated && fd.Message() != nil
isProto2Scalar := fd.Syntax() == protoreflect.Proto2 && fd.Default().IsValid()
isSingularMessage := fd.Cardinality() != protoreflect.Repeated && fd.Message() != nil
if isProto2Scalar || isSingularMessage {
v = pref.Value{} // use invalid value to emit null
v = protoreflect.Value{} // use invalid value to emit null
}
if !f(fd, v) {
return
@ -199,7 +198,7 @@ func (m unpopulatedFieldRanger) Range(f func(pref.FieldDescriptor, pref.Value) b
// marshalMessage marshals the fields in the given protoreflect.Message.
// If the typeURL is non-empty, then a synthetic "@type" field is injected
// containing the URL as the value.
func (e encoder) marshalMessage(m pref.Message, typeURL string) error {
func (e encoder) marshalMessage(m protoreflect.Message, typeURL string) error {
if !flags.ProtoLegacy && messageset.IsMessageSet(m.Descriptor()) {
return errors.New("no support for proto1 MessageSets")
}
@ -220,7 +219,7 @@ func (e encoder) marshalMessage(m pref.Message, typeURL string) error {
}
var err error
order.RangeFields(fields, order.IndexNameFieldOrder, func(fd pref.FieldDescriptor, v pref.Value) bool {
order.RangeFields(fields, order.IndexNameFieldOrder, func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool {
name := fd.JSONName()
if e.opts.UseProtoNames {
name = fd.TextName()
@ -238,7 +237,7 @@ func (e encoder) marshalMessage(m pref.Message, typeURL string) error {
}
// marshalValue marshals the given protoreflect.Value.
func (e encoder) marshalValue(val pref.Value, fd pref.FieldDescriptor) error {
func (e encoder) marshalValue(val protoreflect.Value, fd protoreflect.FieldDescriptor) error {
switch {
case fd.IsList():
return e.marshalList(val.List(), fd)
@ -251,44 +250,44 @@ func (e encoder) marshalValue(val pref.Value, fd pref.FieldDescriptor) error {
// marshalSingular marshals the given non-repeated field value. This includes
// all scalar types, enums, messages, and groups.
func (e encoder) marshalSingular(val pref.Value, fd pref.FieldDescriptor) error {
func (e encoder) marshalSingular(val protoreflect.Value, fd protoreflect.FieldDescriptor) error {
if !val.IsValid() {
e.WriteNull()
return nil
}
switch kind := fd.Kind(); kind {
case pref.BoolKind:
case protoreflect.BoolKind:
e.WriteBool(val.Bool())
case pref.StringKind:
case protoreflect.StringKind:
if e.WriteString(val.String()) != nil {
return errors.InvalidUTF8(string(fd.FullName()))
}
case pref.Int32Kind, pref.Sint32Kind, pref.Sfixed32Kind:
case protoreflect.Int32Kind, protoreflect.Sint32Kind, protoreflect.Sfixed32Kind:
e.WriteInt(val.Int())
case pref.Uint32Kind, pref.Fixed32Kind:
case protoreflect.Uint32Kind, protoreflect.Fixed32Kind:
e.WriteUint(val.Uint())
case pref.Int64Kind, pref.Sint64Kind, pref.Uint64Kind,
pref.Sfixed64Kind, pref.Fixed64Kind:
case protoreflect.Int64Kind, protoreflect.Sint64Kind, protoreflect.Uint64Kind,
protoreflect.Sfixed64Kind, protoreflect.Fixed64Kind:
// 64-bit integers are written out as JSON string.
e.WriteString(val.String())
case pref.FloatKind:
case protoreflect.FloatKind:
// Encoder.WriteFloat handles the special numbers NaN and infinites.
e.WriteFloat(val.Float(), 32)
case pref.DoubleKind:
case protoreflect.DoubleKind:
// Encoder.WriteFloat handles the special numbers NaN and infinites.
e.WriteFloat(val.Float(), 64)
case pref.BytesKind:
case protoreflect.BytesKind:
e.WriteString(base64.StdEncoding.EncodeToString(val.Bytes()))
case pref.EnumKind:
case protoreflect.EnumKind:
if fd.Enum().FullName() == genid.NullValue_enum_fullname {
e.WriteNull()
} else {
@ -300,7 +299,7 @@ func (e encoder) marshalSingular(val pref.Value, fd pref.FieldDescriptor) error
}
}
case pref.MessageKind, pref.GroupKind:
case protoreflect.MessageKind, protoreflect.GroupKind:
if err := e.marshalMessage(val.Message(), ""); err != nil {
return err
}
@ -312,7 +311,7 @@ func (e encoder) marshalSingular(val pref.Value, fd pref.FieldDescriptor) error
}
// marshalList marshals the given protoreflect.List.
func (e encoder) marshalList(list pref.List, fd pref.FieldDescriptor) error {
func (e encoder) marshalList(list protoreflect.List, fd protoreflect.FieldDescriptor) error {
e.StartArray()
defer e.EndArray()
@ -326,12 +325,12 @@ func (e encoder) marshalList(list pref.List, fd pref.FieldDescriptor) error {
}
// marshalMap marshals given protoreflect.Map.
func (e encoder) marshalMap(mmap pref.Map, fd pref.FieldDescriptor) error {
func (e encoder) marshalMap(mmap protoreflect.Map, fd protoreflect.FieldDescriptor) error {
e.StartObject()
defer e.EndObject()
var err error
order.RangeEntries(mmap, order.GenericKeyOrder, func(k pref.MapKey, v pref.Value) bool {
order.RangeEntries(mmap, order.GenericKeyOrder, func(k protoreflect.MapKey, v protoreflect.Value) bool {
if err = e.WriteName(k.String()); err != nil {
return false
}

39
encoding/prototext/encode.go
View File

@ -20,7 +20,6 @@ import (
"google.golang.org/protobuf/internal/strs"
"google.golang.org/protobuf/proto"
"google.golang.org/protobuf/reflect/protoreflect"
pref "google.golang.org/protobuf/reflect/protoreflect"
"google.golang.org/protobuf/reflect/protoregistry"
)
@ -150,7 +149,7 @@ type encoder struct {
}
// marshalMessage marshals the given protoreflect.Message.
func (e encoder) marshalMessage(m pref.Message, inclDelims bool) error {
func (e encoder) marshalMessage(m protoreflect.Message, inclDelims bool) error {
messageDesc := m.Descriptor()
if !flags.ProtoLegacy && messageset.IsMessageSet(messageDesc) {
return errors.New("no support for proto1 MessageSets")
@ -190,7 +189,7 @@ func (e encoder) marshalMessage(m pref.Message, inclDelims bool) error {
}
// marshalField marshals the given field with protoreflect.Value.
func (e encoder) marshalField(name string, val pref.Value, fd pref.FieldDescriptor) error {
func (e encoder) marshalField(name string, val protoreflect.Value, fd protoreflect.FieldDescriptor) error {
switch {
case fd.IsList():
return e.marshalList(name, val.List(), fd)
@ -204,40 +203,40 @@ func (e encoder) marshalField(name string, val pref.Value, fd pref.FieldDescript
// marshalSingular marshals the given non-repeated field value. This includes
// all scalar types, enums, messages, and groups.
func (e encoder) marshalSingular(val pref.Value, fd pref.FieldDescriptor) error {
func (e encoder) marshalSingular(val protoreflect.Value, fd protoreflect.FieldDescriptor) error {
kind := fd.Kind()
switch kind {
case pref.BoolKind:
case protoreflect.BoolKind:
e.WriteBool(val.Bool())
case pref.StringKind:
case protoreflect.StringKind:
s := val.String()
if !e.opts.allowInvalidUTF8 && strs.EnforceUTF8(fd) && !utf8.ValidString(s) {
return errors.InvalidUTF8(string(fd.FullName()))
}
e.WriteString(s)
case pref.Int32Kind, pref.Int64Kind,
pref.Sint32Kind, pref.Sint64Kind,
pref.Sfixed32Kind, pref.Sfixed64Kind:
case protoreflect.Int32Kind, protoreflect.Int64Kind,
protoreflect.Sint32Kind, protoreflect.Sint64Kind,
protoreflect.Sfixed32Kind, protoreflect.Sfixed64Kind:
e.WriteInt(val.Int())
case pref.Uint32Kind, pref.Uint64Kind,
pref.Fixed32Kind, pref.Fixed64Kind:
case protoreflect.Uint32Kind, protoreflect.Uint64Kind,
protoreflect.Fixed32Kind, protoreflect.Fixed64Kind:
e.WriteUint(val.Uint())
case pref.FloatKind:
case protoreflect.FloatKind:
// Encoder.WriteFloat handles the special numbers NaN and infinites.
e.WriteFloat(val.Float(), 32)
case pref.DoubleKind:
case protoreflect.DoubleKind:
// Encoder.WriteFloat handles the special numbers NaN and infinites.
e.WriteFloat(val.Float(), 64)
case pref.BytesKind:
case protoreflect.BytesKind:
e.WriteString(string(val.Bytes()))
case pref.EnumKind:
case protoreflect.EnumKind:
num := val.Enum()
if desc := fd.Enum().Values().ByNumber(num); desc != nil {
e.WriteLiteral(string(desc.Name()))
@ -246,7 +245,7 @@ func (e encoder) marshalSingular(val pref.Value, fd pref.FieldDescriptor) error
e.WriteInt(int64(num))
}
case pref.MessageKind, pref.GroupKind:
case protoreflect.MessageKind, protoreflect.GroupKind:
return e.marshalMessage(val.Message(), true)
default:
@ -256,7 +255,7 @@ func (e encoder) marshalSingular(val pref.Value, fd pref.FieldDescriptor) error
}
// marshalList marshals the given protoreflect.List as multiple name-value fields.
func (e encoder) marshalList(name string, list pref.List, fd pref.FieldDescriptor) error {
func (e encoder) marshalList(name string, list protoreflect.List, fd protoreflect.FieldDescriptor) error {
size := list.Len()
for i := 0; i < size; i++ {
e.WriteName(name)
@ -268,9 +267,9 @@ func (e encoder) marshalList(name string, list pref.List, fd pref.FieldDescripto
}
// marshalMap marshals the given protoreflect.Map as multiple name-value fields.
func (e encoder) marshalMap(name string, mmap pref.Map, fd pref.FieldDescriptor) error {
func (e encoder) marshalMap(name string, mmap protoreflect.Map, fd protoreflect.FieldDescriptor) error {
var err error
order.RangeEntries(mmap, order.GenericKeyOrder, func(key pref.MapKey, val pref.Value) bool {
order.RangeEntries(mmap, order.GenericKeyOrder, func(key protoreflect.MapKey, val protoreflect.Value) bool {
e.WriteName(name)
e.StartMessage()
defer e.EndMessage()
@ -334,7 +333,7 @@ func (e encoder) marshalUnknown(b []byte) {
// marshalAny marshals the given google.protobuf.Any message in expanded form.
// It returns true if it was able to marshal, else false.
func (e encoder) marshalAny(any pref.Message) bool {
func (e encoder) marshalAny(any protoreflect.Message) bool {
// Construct the embedded message.
fds := any.Descriptor().Fields()
fdType := fds.ByNumber(genid.Any_TypeUrl_field_number)

19
internal/filedesc/build.go
View File

@ -12,8 +12,7 @@ import (
"google.golang.org/protobuf/encoding/protowire"
"google.golang.org/protobuf/internal/genid"
"google.golang.org/protobuf/reflect/protoreflect"
pref "google.golang.org/protobuf/reflect/protoreflect"
preg "google.golang.org/protobuf/reflect/protoregistry"
"google.golang.org/protobuf/reflect/protoregistry"
)
// Builder construct a protoreflect.FileDescriptor from the raw descriptor.
@ -38,7 +37,7 @@ type Builder struct {
// TypeResolver resolves extension field types for descriptor options.
// If nil, it uses protoregistry.GlobalTypes.
TypeResolver interface {
preg.ExtensionTypeResolver
protoregistry.ExtensionTypeResolver
}
// FileRegistry is use to lookup file, enum, and message dependencies.
@ -46,8 +45,8 @@ type Builder struct {
// If nil, it uses protoregistry.GlobalFiles.
FileRegistry interface {
FindFileByPath(string) (protoreflect.FileDescriptor, error)
FindDescriptorByName(pref.FullName) (pref.Descriptor, error)
RegisterFile(pref.FileDescriptor) error
FindDescriptorByName(protoreflect.FullName) (protoreflect.Descriptor, error)
RegisterFile(protoreflect.FileDescriptor) error
}
}
@ -55,8 +54,8 @@ type Builder struct {
// If so, it permits looking up an enum or message dependency based on the
// sub-list and element index into filetype.Builder.DependencyIndexes.
type resolverByIndex interface {
FindEnumByIndex(int32, int32, []Enum, []Message) pref.EnumDescriptor
FindMessageByIndex(int32, int32, []Enum, []Message) pref.MessageDescriptor
FindEnumByIndex(int32, int32, []Enum, []Message) protoreflect.EnumDescriptor
FindMessageByIndex(int32, int32, []Enum, []Message) protoreflect.MessageDescriptor
}
// Indexes of each sub-list in filetype.Builder.DependencyIndexes.
@ -70,7 +69,7 @@ const (
// Out is the output of the Builder.
type Out struct {
File pref.FileDescriptor
File protoreflect.FileDescriptor
// Enums is all enum descriptors in "flattened ordering".
Enums []Enum
@ -97,10 +96,10 @@ func (db Builder) Build() (out Out) {
// Initialize resolvers and registries if unpopulated.
if db.TypeResolver == nil {
db.TypeResolver = preg.GlobalTypes
db.TypeResolver = protoregistry.GlobalTypes
}
if db.FileRegistry == nil {
db.FileRegistry = preg.GlobalFiles
db.FileRegistry = protoregistry.GlobalFiles
}
fd := newRawFile(db)

167
internal/filedesc/desc_list.go
View File

@ -17,31 +17,30 @@ import (
"google.golang.org/protobuf/internal/errors"
"google.golang.org/protobuf/internal/pragma"
"google.golang.org/protobuf/reflect/protoreflect"
pref "google.golang.org/protobuf/reflect/protoreflect"
)
type FileImports []pref.FileImport
type FileImports []protoreflect.FileImport
func (p *FileImports) Len() int { return len(*p) }
func (p *FileImports) Get(i int) pref.FileImport { return (*p)[i] }
func (p *FileImports) Get(i int) protoreflect.FileImport { return (*p)[i] }
func (p *FileImports) Format(s fmt.State, r rune) { descfmt.FormatList(s, r, p) }
func (p *FileImports) ProtoInternal(pragma.DoNotImplement) {}
type Names struct {
List []pref.Name
List []protoreflect.Name
once sync.Once
has map[pref.Name]int // protected by once
has map[protoreflect.Name]int // protected by once
}
func (p *Names) Len() int { return len(p.List) }
func (p *Names) Get(i int) pref.Name { return p.List[i] }
func (p *Names) Has(s pref.Name) bool { return p.lazyInit().has[s] > 0 }
func (p *Names) Get(i int) protoreflect.Name { return p.List[i] }
func (p *Names) Has(s protoreflect.Name) bool { return p.lazyInit().has[s] > 0 }
func (p *Names) Format(s fmt.State, r rune) { descfmt.FormatList(s, r, p) }
func (p *Names) ProtoInternal(pragma.DoNotImplement) {}
func (p *Names) lazyInit() *Names {
p.once.Do(func() {
if len(p.List) > 0 {
p.has = make(map[pref.Name]int, len(p.List))
p.has = make(map[protoreflect.Name]int, len(p.List))
for _, s := range p.List {
p.has[s] = p.has[s] + 1
}
@ -67,14 +66,14 @@ func (p *Names) CheckValid() error {
}
type EnumRanges struct {
List [][2]pref.EnumNumber // start inclusive; end inclusive
List [][2]protoreflect.EnumNumber // start inclusive; end inclusive
once sync.Once
sorted [][2]pref.EnumNumber // protected by once
sorted [][2]protoreflect.EnumNumber // protected by once
}
func (p *EnumRanges) Len() int { return len(p.List) }
func (p *EnumRanges) Get(i int) [2]pref.EnumNumber { return p.List[i] }
func (p *EnumRanges) Has(n pref.EnumNumber) bool {
func (p *EnumRanges) Len() int { return len(p.List) }
func (p *EnumRanges) Get(i int) [2]protoreflect.EnumNumber { return p.List[i] }
func (p *EnumRanges) Has(n protoreflect.EnumNumber) bool {
for ls := p.lazyInit().sorted; len(ls) > 0; {
i := len(ls) / 2
switch r := enumRange(ls[i]); {
@ -129,14 +128,14 @@ func (r enumRange) String() string {
}
type FieldRanges struct {
List [][2]pref.FieldNumber // start inclusive; end exclusive
List [][2]protoreflect.FieldNumber // start inclusive; end exclusive
once sync.Once
sorted [][2]pref.FieldNumber // protected by once
sorted [][2]protoreflect.FieldNumber // protected by once
}
func (p *FieldRanges) Len() int { return len(p.List) }
func (p *FieldRanges) Get(i int) [2]pref.FieldNumber { return p.List[i] }
func (p *FieldRanges) Has(n pref.FieldNumber) bool {
func (p *FieldRanges) Len() int { return len(p.List) }
func (p *FieldRanges) Get(i int) [2]protoreflect.FieldNumber { return p.List[i] }
func (p *FieldRanges) Has(n protoreflect.FieldNumber) bool {
for ls := p.lazyInit().sorted; len(ls) > 0; {
i := len(ls) / 2
switch r := fieldRange(ls[i]); {
@ -221,17 +220,17 @@ func (r fieldRange) String() string {
}
type FieldNumbers struct {
List []pref.FieldNumber
List []protoreflect.FieldNumber
once sync.Once
has map[pref.FieldNumber]struct{} // protected by once
has map[protoreflect.FieldNumber]struct{} // protected by once
}
func (p *FieldNumbers) Len() int { return len(p.List) }
func (p *FieldNumbers) Get(i int) pref.FieldNumber { return p.List[i] }
func (p *FieldNumbers) Has(n pref.FieldNumber) bool {
func (p *FieldNumbers) Len() int { return len(p.List) }
func (p *FieldNumbers) Get(i int) protoreflect.FieldNumber { return p.List[i] }
func (p *FieldNumbers) Has(n protoreflect.FieldNumber) bool {
p.once.Do(func() {
if len(p.List) > 0 {
p.has = make(map[pref.FieldNumber]struct{}, len(p.List))
p.has = make(map[protoreflect.FieldNumber]struct{}, len(p.List))
for _, n := range p.List {
p.has[n] = struct{}{}
}
@ -244,30 +243,38 @@ func (p *FieldNumbers) Format(s fmt.State, r rune) { descfmt.FormatList
func (p *FieldNumbers) ProtoInternal(pragma.DoNotImplement) {}
type OneofFields struct {
List []pref.FieldDescriptor
List []protoreflect.FieldDescriptor
once sync.Once
byName map[pref.Name]pref.FieldDescriptor // protected by once
byJSON map[string]pref.FieldDescriptor // protected by once
byText map[string]pref.FieldDescriptor // protected by once
byNum map[pref.FieldNumber]pref.FieldDescriptor // protected by once
byName map[protoreflect.Name]protoreflect.FieldDescriptor // protected by once
byJSON map[string]protoreflect.FieldDescriptor // protected by once
byText map[string]protoreflect.FieldDescriptor // protected by once
byNum map[protoreflect.FieldNumber]protoreflect.FieldDescriptor // protected by once
}
func (p *OneofFields) Len() int { return len(p.List) }
func (p *OneofFields) Get(i int) pref.FieldDescriptor { return p.List[i] }
func (p *OneofFields) ByName(s pref.Name) pref.FieldDescriptor { return p.lazyInit().byName[s] }
func (p *OneofFields) ByJSONName(s string) pref.FieldDescriptor { return p.lazyInit().byJSON[s] }
func (p *OneofFields) ByTextName(s string) pref.FieldDescriptor { return p.lazyInit().byText[s] }
func (p *OneofFields) ByNumber(n pref.FieldNumber) pref.FieldDescriptor { return p.lazyInit().byNum[n] }
func (p *OneofFields) Format(s fmt.State, r rune) { descfmt.FormatList(s, r, p) }
func (p *OneofFields) ProtoInternal(pragma.DoNotImplement) {}
func (p *OneofFields) Len() int { return len(p.List) }
func (p *OneofFields) Get(i int) protoreflect.FieldDescriptor { return p.List[i] }
func (p *OneofFields) ByName(s protoreflect.Name) protoreflect.FieldDescriptor {
return p.lazyInit().byName[s]
}
func (p *OneofFields) ByJSONName(s string) protoreflect.FieldDescriptor {
return p.lazyInit().byJSON[s]
}
func (p *OneofFields) ByTextName(s string) protoreflect.FieldDescriptor {
return p.lazyInit().byText[s]
}
func (p *OneofFields) ByNumber(n protoreflect.FieldNumber) protoreflect.FieldDescriptor {
return p.lazyInit().byNum[n]
}
func (p *OneofFields) Format(s fmt.State, r rune) { descfmt.FormatList(s, r, p) }
func (p *OneofFields) ProtoInternal(pragma.DoNotImplement) {}
func (p *OneofFields) lazyInit() *OneofFields {
p.once.Do(func() {
if len(p.List) > 0 {
p.byName = make(map[pref.Name]pref.FieldDescriptor, len(p.List))
p.byJSON = make(map[string]pref.FieldDescriptor, len(p.List))
p.byText = make(map[string]pref.FieldDescriptor, len(p.List))
p.byNum = make(map[pref.FieldNumber]pref.FieldDescriptor, len(p.List))
p.byName = make(map[protoreflect.Name]protoreflect.FieldDescriptor, len(p.List))
p.byJSON = make(map[string]protoreflect.FieldDescriptor, len(p.List))
p.byText = make(map[string]protoreflect.FieldDescriptor, len(p.List))
p.byNum = make(map[protoreflect.FieldNumber]protoreflect.FieldDescriptor, len(p.List))
for _, f := range p.List {
// Field names and numbers are guaranteed to be unique.
p.byName[f.Name()] = f
@ -284,123 +291,123 @@ type SourceLocations struct {
// List is a list of SourceLocations.
// The SourceLocation.Next field does not need to be populated
// as it will be lazily populated upon first need.
List []pref.SourceLocation
List []protoreflect.SourceLocation
// File is the parent file descriptor that these locations are relative to.
// If non-nil, ByDescriptor verifies that the provided descriptor
// is a child of this file descriptor.
File pref.FileDescriptor
File protoreflect.FileDescriptor
once sync.Once
byPath map[pathKey]int
}
func (p *SourceLocations) Len() int { return len(p.List) }
func (p *SourceLocations) Get(i int) pref.SourceLocation { return p.lazyInit().List[i] }
func (p *SourceLocations) byKey(k pathKey) pref.SourceLocation {
func (p *SourceLocations) Len() int { return len(p.List) }
func (p *SourceLocations) Get(i int) protoreflect.SourceLocation { return p.lazyInit().List[i] }
func (p *SourceLocations) byKey(k pathKey) protoreflect.SourceLocation {
if i, ok := p.lazyInit().byPath[k]; ok {
return p.List[i]
}
return pref.SourceLocation{}
return protoreflect.SourceLocation{}
}
func (p *SourceLocations) ByPath(path pref.SourcePath) pref.SourceLocation {
func (p *SourceLocations) ByPath(path protoreflect.SourcePath) protoreflect.SourceLocation {
return p.byKey(newPathKey(path))
}
func (p *SourceLocations) ByDescriptor(desc pref.Descriptor) pref.SourceLocation {
func (p *SourceLocations) ByDescriptor(desc protoreflect.Descriptor) protoreflect.SourceLocation {
if p.File != nil && desc != nil && p.File != desc.ParentFile() {
return pref.SourceLocation{} // mismatching parent files
return protoreflect.SourceLocation{} // mismatching parent files
}
var pathArr [16]int32
path := pathArr[:0]
for {
switch desc.(type) {
case pref.FileDescriptor:
case protoreflect.FileDescriptor:
// Reverse the path since it was constructed in reverse.
for i, j := 0, len(path)-1; i < j; i, j = i+1, j-1 {
path[i], path[j] = path[j], path[i]
}
return p.byKey(newPathKey(path))
case pref.MessageDescriptor:
case protoreflect.MessageDescriptor:
path = append(path, int32(desc.Index()))
desc = desc.Parent()
switch desc.(type) {
case pref.FileDescriptor:
case protoreflect.FileDescriptor:
path = append(path, int32(genid.FileDescriptorProto_MessageType_field_number))
case pref.MessageDescriptor:
case protoreflect.MessageDescriptor:
path = append(path, int32(genid.DescriptorProto_NestedType_field_number))
default:
return pref.SourceLocation{}
return protoreflect.SourceLocation{}
}
case pref.FieldDescriptor:
isExtension := desc.(pref.FieldDescriptor).IsExtension()
case protoreflect.FieldDescriptor:
isExtension := desc.(protoreflect.FieldDescriptor).IsExtension()
path = append(path, int32(desc.Index()))
desc = desc.Parent()
if isExtension {
switch desc.(type) {
case pref.FileDescriptor:
case protoreflect.FileDescriptor:
path = append(path, int32(genid.FileDescriptorProto_Extension_field_number))
case pref.MessageDescriptor:
case protoreflect.MessageDescriptor:
path = append(path, int32(genid.DescriptorProto_Extension_field_number))
default:
return pref.SourceLocation{}
return protoreflect.SourceLocation{}
}
} else {
switch desc.(type) {
case pref.MessageDescriptor:
case protoreflect.MessageDescriptor:
path = append(path, int32(genid.DescriptorProto_Field_field_number))
default:
return pref.SourceLocation{}
return protoreflect.SourceLocation{}
}
}
case pref.OneofDescriptor:
case protoreflect.OneofDescriptor:
path = append(path, int32(desc.Index()))
desc = desc.Parent()
switch desc.(type) {
case pref.MessageDescriptor:
case protoreflect.MessageDescriptor:
path = append(path, int32(genid.DescriptorProto_OneofDecl_field_number))
default:
return pref.SourceLocation{}
return protoreflect.SourceLocation{}
}
case pref.EnumDescriptor:
case protoreflect.EnumDescriptor:
path = append(path, int32(desc.Index()))
desc = desc.Parent()
switch desc.(type) {
case pref.FileDescriptor:
case protoreflect.FileDescriptor:
path = append(path, int32(genid.FileDescriptorProto_EnumType_field_number))
case pref.MessageDescriptor:
case protoreflect.MessageDescriptor:
path = append(path, int32(genid.DescriptorProto_EnumType_field_number))
default:
return pref.SourceLocation{}
return protoreflect.SourceLocation{}
}
case pref.EnumValueDescriptor:
case protoreflect.EnumValueDescriptor:
path = append(path, int32(desc.Index()))
desc = desc.Parent()
switch desc.(type) {
case pref.EnumDescriptor:
case protoreflect.EnumDescriptor:
path = append(path, int32(genid.EnumDescriptorProto_Value_field_number))
default:
return pref.SourceLocation{}
return protoreflect.SourceLocation{}
}
case pref.ServiceDescriptor:
case protoreflect.ServiceDescriptor:
path = append(path, int32(desc.Index()))
desc = desc.Parent()
switch desc.(type) {
case pref.FileDescriptor:
case protoreflect.FileDescriptor:
path = append(path, int32(genid.FileDescriptorProto_Service_field_number))
default:
return pref.SourceLocation{}
return protoreflect.SourceLocation{}
}
case pref.MethodDescriptor:
case protoreflect.MethodDescriptor:
path = append(path, int32(desc.Index()))
desc = desc.Parent()
switch desc.(type) {
case pref.ServiceDescriptor:
case protoreflect.ServiceDescriptor:
path = append(path, int32(genid.ServiceDescriptorProto_Method_field_number))
default:
return pref.SourceLocation{}
return protoreflect.SourceLocation{}
}
default:
return pref.SourceLocation{}
return protoreflect.SourceLocation{}
}
}
}
@ -435,7 +442,7 @@ type pathKey struct {
str string // used if the path does not fit in arr
}
func newPathKey(p pref.SourcePath) (k pathKey) {
func newPathKey(p protoreflect.SourcePath) (k pathKey) {
if len(p) < len(k.arr) {
for i, ps := range p {
if ps < 0 || math.MaxUint8 <= ps {

21
internal/impl/decode.go
View File

@ -12,9 +12,8 @@ import (
"google.golang.org/protobuf/internal/flags"
"google.golang.org/protobuf/proto"
"google.golang.org/protobuf/reflect/protoreflect"
preg "google.golang.org/protobuf/reflect/protoregistry"
"google.golang.org/protobuf/reflect/protoregistry"
"google.golang.org/protobuf/runtime/protoiface"
piface "google.golang.org/protobuf/runtime/protoiface"
)
var errDecode = errors.New("cannot parse invalid wire-format data")
@ -38,14 +37,16 @@ func (o unmarshalOptions) Options() proto.UnmarshalOptions {
}
}
func (o unmarshalOptions) DiscardUnknown() bool { return o.flags&piface.UnmarshalDiscardUnknown != 0 }
func (o unmarshalOptions) DiscardUnknown() bool {
return o.flags&protoiface.UnmarshalDiscardUnknown != 0
}
func (o unmarshalOptions) IsDefault() bool {
return o.flags == 0 && o.resolver == preg.GlobalTypes
return o.flags == 0 && o.resolver == protoregistry.GlobalTypes
}
var lazyUnmarshalOptions = unmarshalOptions{
resolver: preg.GlobalTypes,
resolver: protoregistry.GlobalTypes,
depth: protowire.DefaultRecursionLimit,
}
@ -55,7 +56,7 @@ type unmarshalOutput struct {
}
// unmarshal is protoreflect.Methods.Unmarshal.
func (mi *MessageInfo) unmarshal(in piface.UnmarshalInput) (piface.UnmarshalOutput, error) {
func (mi *MessageInfo) unmarshal(in protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
var p pointer
if ms, ok := in.Message.(*messageState); ok {
p = ms.pointer()
@ -67,11 +68,11 @@ func (mi *MessageInfo) unmarshal(in piface.UnmarshalInput) (piface.UnmarshalOutp
resolver: in.Resolver,
depth: in.Depth,
})
var flags piface.UnmarshalOutputFlags
var flags protoiface.UnmarshalOutputFlags
if out.initialized {
flags |= piface.UnmarshalInitialized
flags |= protoiface.UnmarshalInitialized
}
return piface.UnmarshalOutput{
return protoiface.UnmarshalOutput{
Flags: flags,
}, err
}
@ -210,7 +211,7 @@ func (mi *MessageInfo) unmarshalExtension(b []byte, num protowire.Number, wtyp p
var err error
xt, err = opts.resolver.FindExtensionByNumber(mi.Desc.FullName(), num)
if err != nil {
if err == preg.NotFound {
if err == protoregistry.NotFound {
return out, errUnknown
}
return out, errors.New("%v: unable to resolve extension %v: %v", mi.Desc.FullName(), num, err)

57
internal/impl/legacy_enum.go
View File

@ -13,13 +13,12 @@ import (
"google.golang.org/protobuf/internal/filedesc"
"google.golang.org/protobuf/internal/strs"
"google.golang.org/protobuf/reflect/protoreflect"
pref "google.golang.org/protobuf/reflect/protoreflect"
)
// legacyEnumName returns the name of enums used in legacy code.
// It is neither the protobuf full name nor the qualified Go name,
// but rather an odd hybrid of both.
func legacyEnumName(ed pref.EnumDescriptor) string {
func legacyEnumName(ed protoreflect.EnumDescriptor) string {
var protoPkg string
enumName := string(ed.FullName())
if fd := ed.ParentFile(); fd != nil {
@ -34,68 +33,68 @@ func legacyEnumName(ed pref.EnumDescriptor) string {
// legacyWrapEnum wraps v as a protoreflect.Enum,
// where v must be a int32 kind and not implement the v2 API already.
func legacyWrapEnum(v reflect.Value) pref.Enum {
func legacyWrapEnum(v reflect.Value) protoreflect.Enum {
et := legacyLoadEnumType(v.Type())
return et.New(pref.EnumNumber(v.Int()))
return et.New(protoreflect.EnumNumber(v.Int()))
}
var legacyEnumTypeCache sync.Map // map[reflect.Type]protoreflect.EnumType
// legacyLoadEnumType dynamically loads a protoreflect.EnumType for t,
// where t must be an int32 kind and not implement the v2 API already.
func legacyLoadEnumType(t reflect.Type) pref.EnumType {
func legacyLoadEnumType(t reflect.Type) protoreflect.EnumType {
// Fast-path: check if a EnumType is cached for this concrete type.
if et, ok := legacyEnumTypeCache.Load(t); ok {
return et.(pref.EnumType)
return et.(protoreflect.EnumType)
}
// Slow-path: derive enum descriptor and initialize EnumType.
var et pref.EnumType
var et protoreflect.EnumType
ed := LegacyLoadEnumDesc(t)
et = &legacyEnumType{
desc: ed,
goType: t,
}
if et, ok := legacyEnumTypeCache.LoadOrStore(t, et); ok {
return et.(pref.EnumType)
return et.(protoreflect.EnumType)
}
return et
}
type legacyEnumType struct {
desc pref.EnumDescriptor
desc protoreflect.EnumDescriptor
goType reflect.Type
m sync.Map // map[protoreflect.EnumNumber]proto.Enum
}
func (t *legacyEnumType) New(n pref.EnumNumber) pref.Enum {
func (t *legacyEnumType) New(n protoreflect.EnumNumber) protoreflect.Enum {
if e, ok := t.m.Load(n); ok {
return e.(pref.Enum)
return e.(protoreflect.Enum)
}
e := &legacyEnumWrapper{num: n, pbTyp: t, goTyp: t.goType}
t.m.Store(n, e)
return e
}
func (t *legacyEnumType) Descriptor() pref.EnumDescriptor {
func (t *legacyEnumType) Descriptor() protoreflect.EnumDescriptor {
return t.desc
}
type legacyEnumWrapper struct {
num pref.EnumNumber
pbTyp pref.EnumType
num protoreflect.EnumNumber
pbTyp protoreflect.EnumType
goTyp reflect.Type
}
func (e *legacyEnumWrapper) Descriptor() pref.EnumDescriptor {
func (e *legacyEnumWrapper) Descriptor() protoreflect.EnumDescriptor {
return e.pbTyp.Descriptor()
}
func (e *legacyEnumWrapper) Type() pref.EnumType {
func (e *legacyEnumWrapper) Type() protoreflect.EnumType {
return e.pbTyp
}
func (e *legacyEnumWrapper) Number() pref.EnumNumber {
func (e *legacyEnumWrapper) Number() protoreflect.EnumNumber {
return e.num
}
func (e *legacyEnumWrapper) ProtoReflect() pref.Enum {
func (e *legacyEnumWrapper) ProtoReflect() protoreflect.Enum {
return e
}
func (e *legacyEnumWrapper) protoUnwrap() interface{} {
@ -105,8 +104,8 @@ func (e *legacyEnumWrapper) protoUnwrap() interface{} {
}
var (
_ pref.Enum = (*legacyEnumWrapper)(nil)
_ unwrapper = (*legacyEnumWrapper)(nil)
_ protoreflect.Enum = (*legacyEnumWrapper)(nil)
_ unwrapper = (*legacyEnumWrapper)(nil)
)
var legacyEnumDescCache sync.Map // map[reflect.Type]protoreflect.EnumDescriptor
@ -115,15 +114,15 @@ var legacyEnumDescCache sync.Map // map[reflect.Type]protoreflect.EnumDescriptor
// which must be an int32 kind and not implement the v2 API already.
//
// This is exported for testing purposes.
func LegacyLoadEnumDesc(t reflect.Type) pref.EnumDescriptor {
func LegacyLoadEnumDesc(t reflect.Type) protoreflect.EnumDescriptor {
// Fast-path: check if an EnumDescriptor is cached for this concrete type.
if ed, ok := legacyEnumDescCache.Load(t); ok {
return ed.(pref.EnumDescriptor)
return ed.(protoreflect.EnumDescriptor)
}
// Slow-path: initialize EnumDescriptor from the raw descriptor.
ev := reflect.Zero(t).Interface()
if _, ok := ev.(pref.Enum); ok {
if _, ok := ev.(protoreflect.Enum); ok {
panic(fmt.Sprintf("%v already implements proto.Enum", t))
}
edV1, ok := ev.(enumV1)
@ -132,7 +131,7 @@ func LegacyLoadEnumDesc(t reflect.Type) pref.EnumDescriptor {
}
b, idxs := edV1.EnumDescriptor()
var ed pref.EnumDescriptor
var ed protoreflect.EnumDescriptor
if len(idxs) == 1 {
ed = legacyLoadFileDesc(b).Enums().Get(idxs[0])
} else {
@ -158,10 +157,10 @@ var aberrantEnumDescCache sync.Map // map[reflect.Type]protoreflect.EnumDescript
// We are unable to use the global enum registry since it is
// unfortunately keyed by the protobuf full name, which we also do not know.
// Thus, this produces some bogus enum descriptor based on the Go type name.
func aberrantLoadEnumDesc(t reflect.Type) pref.EnumDescriptor {
func aberrantLoadEnumDesc(t reflect.Type) protoreflect.EnumDescriptor {
// Fast-path: check if an EnumDescriptor is cached for this concrete type.
if ed, ok := aberrantEnumDescCache.Load(t); ok {
return ed.(pref.EnumDescriptor)
return ed.(protoreflect.EnumDescriptor)
}
// Slow-path: construct a bogus, but unique EnumDescriptor.
@ -182,7 +181,7 @@ func aberrantLoadEnumDesc(t reflect.Type) pref.EnumDescriptor {
// An exhaustive query is clearly impractical, but can be best-effort.
if ed, ok := aberrantEnumDescCache.LoadOrStore(t, ed); ok {
return ed.(pref.EnumDescriptor)
return ed.(protoreflect.EnumDescriptor)
}
return ed
}
@ -192,7 +191,7 @@ func aberrantLoadEnumDesc(t reflect.Type) pref.EnumDescriptor {
// It should be sufficiently unique within a program.
//
// This is exported for testing purposes.
func AberrantDeriveFullName(t reflect.Type) pref.FullName {
func AberrantDeriveFullName(t reflect.Type) protoreflect.FullName {
sanitize := func(r rune) rune {
switch {
case r == '/':
@ -215,5 +214,5 @@ func AberrantDeriveFullName(t reflect.Type) pref.FullName {
ss[i] = "x" + s
}
}
return pref.FullName(strings.Join(ss, "."))
return protoreflect.FullName(strings.Join(ss, "."))
}

122
internal/impl/legacy_message.go
View File

@ -16,14 +16,12 @@ import (
"google.golang.org/protobuf/internal/filedesc"
"google.golang.org/protobuf/internal/strs"
"google.golang.org/protobuf/reflect/protoreflect"
pref "google.golang.org/protobuf/reflect/protoreflect"
"google.golang.org/protobuf/runtime/protoiface"
piface "google.golang.org/protobuf/runtime/protoiface"
)
// legacyWrapMessage wraps v as a protoreflect.Message,
// where v must be a *struct kind and not implement the v2 API already.
func legacyWrapMessage(v reflect.Value) pref.Message {
func legacyWrapMessage(v reflect.Value) protoreflect.Message {
t := v.Type()
if t.Kind() != reflect.Ptr || t.Elem().Kind() != reflect.Struct {
return aberrantMessage{v: v}
@ -35,7 +33,7 @@ func legacyWrapMessage(v reflect.Value) pref.Message {
// legacyLoadMessageType dynamically loads a protoreflect.Type for t,
// where t must be not implement the v2 API already.
// The provided name is used if it cannot be determined from the message.
func legacyLoadMessageType(t reflect.Type, name pref.FullName) protoreflect.MessageType {
func legacyLoadMessageType(t reflect.Type, name protoreflect.FullName) protoreflect.MessageType {
if t.Kind() != reflect.Ptr || t.Elem().Kind() != reflect.Struct {
return aberrantMessageType{t}
}
@ -47,7 +45,7 @@ var legacyMessageTypeCache sync.Map // map[reflect.Type]*MessageInfo
// legacyLoadMessageInfo dynamically loads a *MessageInfo for t,
// where t must be a *struct kind and not implement the v2 API already.
// The provided name is used if it cannot be determined from the message.
func legacyLoadMessageInfo(t reflect.Type, name pref.FullName) *MessageInfo {
func legacyLoadMessageInfo(t reflect.Type, name protoreflect.FullName) *MessageInfo {
// Fast-path: check if a MessageInfo is cached for this concrete type.
if mt, ok := legacyMessageTypeCache.Load(t); ok {
return mt.(*MessageInfo)
@ -68,7 +66,7 @@ func legacyLoadMessageInfo(t reflect.Type, name pref.FullName) *MessageInfo {
// supports deterministic serialization or not, but this
// preserves the v1 implementation's behavior of always
// calling Marshal methods when present.
mi.methods.Flags |= piface.SupportMarshalDeterministic
mi.methods.Flags |= protoiface.SupportMarshalDeterministic
}
if _, hasUnmarshal = v.(legacyUnmarshaler); hasUnmarshal {
mi.methods.Unmarshal = legacyUnmarshal
@ -89,18 +87,18 @@ var legacyMessageDescCache sync.Map // map[reflect.Type]protoreflect.MessageDesc
// which should be a *struct kind and must not implement the v2 API already.
//
// This is exported for testing purposes.
func LegacyLoadMessageDesc(t reflect.Type) pref.MessageDescriptor {
func LegacyLoadMessageDesc(t reflect.Type) protoreflect.MessageDescriptor {
return legacyLoadMessageDesc(t, "")
}
func legacyLoadMessageDesc(t reflect.Type, name pref.FullName) pref.MessageDescriptor {
func legacyLoadMessageDesc(t reflect.Type, name protoreflect.FullName) protoreflect.MessageDescriptor {
// Fast-path: check if a MessageDescriptor is cached for this concrete type.
if mi, ok := legacyMessageDescCache.Load(t); ok {
return mi.(pref.MessageDescriptor)
return mi.(protoreflect.MessageDescriptor)
}
// Slow-path: initialize MessageDescriptor from the raw descriptor.
mv := reflect.Zero(t).Interface()
if _, ok := mv.(pref.ProtoMessage); ok {
if _, ok := mv.(protoreflect.ProtoMessage); ok {
panic(fmt.Sprintf("%v already implements proto.Message", t))
}
mdV1, ok := mv.(messageV1)
@ -164,7 +162,7 @@ var (
//
// This is a best-effort derivation of the message descriptor using the protobuf
// tags on the struct fields.
func aberrantLoadMessageDesc(t reflect.Type, name pref.FullName) pref.MessageDescriptor {
func aberrantLoadMessageDesc(t reflect.Type, name protoreflect.FullName) protoreflect.MessageDescriptor {
aberrantMessageDescLock.Lock()
defer aberrantMessageDescLock.Unlock()
if aberrantMessageDescCache == nil {
@ -172,7 +170,7 @@ func aberrantLoadMessageDesc(t reflect.Type, name pref.FullName) pref.MessageDes
}
return aberrantLoadMessageDescReentrant(t, name)
}
func aberrantLoadMessageDescReentrant(t reflect.Type, name pref.FullName) pref.MessageDescriptor {
func aberrantLoadMessageDescReentrant(t reflect.Type, name protoreflect.FullName) protoreflect.MessageDescriptor {
// Fast-path: check if an MessageDescriptor is cached for this concrete type.
if md, ok := aberrantMessageDescCache[t]; ok {
return md
@ -225,9 +223,9 @@ func aberrantLoadMessageDescReentrant(t reflect.Type, name pref.FullName) pref.M
vs := fn.Func.Call([]reflect.Value{reflect.Zero(fn.Type.In(0))})[0]
for i := 0; i < vs.Len(); i++ {
v := vs.Index(i)
md.L2.ExtensionRanges.List = append(md.L2.ExtensionRanges.List, [2]pref.FieldNumber{
pref.FieldNumber(v.FieldByName("Start").Int()),
pref.FieldNumber(v.FieldByName("End").Int() + 1),
md.L2.ExtensionRanges.List = append(md.L2.ExtensionRanges.List, [2]protoreflect.FieldNumber{
protoreflect.FieldNumber(v.FieldByName("Start").Int()),
protoreflect.FieldNumber(v.FieldByName("End").Int() + 1),
})
md.L2.ExtensionRangeOptions = append(md.L2.ExtensionRangeOptions, nil)
}
@ -245,7 +243,7 @@ func aberrantLoadMessageDescReentrant(t reflect.Type, name pref.FullName) pref.M
n := len(md.L2.Oneofs.List)
md.L2.Oneofs.List = append(md.L2.Oneofs.List, filedesc.Oneof{})
od := &md.L2.Oneofs.List[n]
od.L0.FullName = md.FullName().Append(pref.Name(tag))
od.L0.FullName = md.FullName().Append(protoreflect.Name(tag))
od.L0.ParentFile = md.L0.ParentFile
od.L0.Parent = md
od.L0.Index = n
@ -267,14 +265,14 @@ func aberrantLoadMessageDescReentrant(t reflect.Type, name pref.FullName) pref.M
return md
}
func aberrantDeriveMessageName(t reflect.Type, name pref.FullName) pref.FullName {
func aberrantDeriveMessageName(t reflect.Type, name protoreflect.FullName) protoreflect.FullName {
if name.IsValid() {
return name
}
func() {
defer func() { recover() }() // swallow possible nil panics
if m, ok := reflect.Zero(t).Interface().(interface{ XXX_MessageName() string }); ok {
name = pref.FullName(m.XXX_MessageName())
name = protoreflect.FullName(m.XXX_MessageName())
}
}()
if name.IsValid() {
@ -305,7 +303,7 @@ func aberrantAppendField(md *filedesc.Message, goType reflect.Type, tag, tagKey,
fd.L0.Index = n
if fd.L1.IsWeak || fd.L1.HasPacked {
fd.L1.Options = func() pref.ProtoMessage {
fd.L1.Options = func() protoreflect.ProtoMessage {
opts := descopts.Field.ProtoReflect().New()
if fd.L1.IsWeak {
opts.Set(opts.Descriptor().Fields().ByName("weak"), protoreflect.ValueOfBool(true))
@ -318,17 +316,17 @@ func aberrantAppendField(md *filedesc.Message, goType reflect.Type, tag, tagKey,
}
// Populate Enum and Message.
if fd.Enum() == nil && fd.Kind() == pref.EnumKind {
if fd.Enum() == nil && fd.Kind() == protoreflect.EnumKind {
switch v := reflect.Zero(t).Interface().(type) {
case pref.Enum:
case protoreflect.Enum:
fd.L1.Enum = v.Descriptor()
default:
fd.L1.Enum = LegacyLoadEnumDesc(t)
}
}
if fd.Message() == nil && (fd.Kind() == pref.MessageKind || fd.Kind() == pref.GroupKind) {
if fd.Message() == nil && (fd.Kind() == protoreflect.MessageKind || fd.Kind() == protoreflect.GroupKind) {
switch v := reflect.Zero(t).Interface().(type) {
case pref.ProtoMessage:
case protoreflect.ProtoMessage:
fd.L1.Message = v.ProtoReflect().Descriptor()
case messageV1:
fd.L1.Message = LegacyLoadMessageDesc(t)
@ -337,13 +335,13 @@ func aberrantAppendField(md *filedesc.Message, goType reflect.Type, tag, tagKey,
n := len(md.L1.Messages.List)
md.L1.Messages.List = append(md.L1.Messages.List, filedesc.Message{L2: new(filedesc.MessageL2)})
md2 := &md.L1.Messages.List[n]
md2.L0.FullName = md.FullName().Append(pref.Name(strs.MapEntryName(string(fd.Name()))))
md2.L0.FullName = md.FullName().Append(protoreflect.Name(strs.MapEntryName(string(fd.Name()))))
md2.L0.ParentFile = md.L0.ParentFile
md2.L0.Parent = md
md2.L0.Index = n
md2.L1.IsMapEntry = true
md2.L2.Options = func() pref.ProtoMessage {
md2.L2.Options = func() protoreflect.ProtoMessage {
opts := descopts.Message.ProtoReflect().New()
opts.Set(opts.Descriptor().Fields().ByName("map_entry"), protoreflect.ValueOfBool(true))
return opts.Interface()
@ -364,8 +362,8 @@ type placeholderEnumValues struct {
protoreflect.EnumValueDescriptors
}
func (placeholderEnumValues) ByNumber(n pref.EnumNumber) pref.EnumValueDescriptor {
return filedesc.PlaceholderEnumValue(pref.FullName(fmt.Sprintf("UNKNOWN_%d", n)))
func (placeholderEnumValues) ByNumber(n protoreflect.EnumNumber) protoreflect.EnumValueDescriptor {
return filedesc.PlaceholderEnumValue(protoreflect.FullName(fmt.Sprintf("UNKNOWN_%d", n)))
}
// legacyMarshaler is the proto.Marshaler interface superseded by protoiface.Methoder.
@ -383,7 +381,7 @@ type legacyMerger interface {
Merge(protoiface.MessageV1)
}
var aberrantProtoMethods = &piface.Methods{
var aberrantProtoMethods = &protoiface.Methods{
Marshal: legacyMarshal,
Unmarshal: legacyUnmarshal,
Merge: legacyMerge,
@ -392,40 +390,40 @@ var aberrantProtoMethods = &piface.Methods{
// supports deterministic serialization or not, but this
// preserves the v1 implementation's behavior of always
// calling Marshal methods when present.
Flags: piface.SupportMarshalDeterministic,
Flags: protoiface.SupportMarshalDeterministic,
}
func legacyMarshal(in piface.MarshalInput) (piface.MarshalOutput, error) {
func legacyMarshal(in protoiface.MarshalInput) (protoiface.MarshalOutput, error) {
v := in.Message.(unwrapper).protoUnwrap()
marshaler, ok := v.(legacyMarshaler)
if !ok {
return piface.MarshalOutput{}, errors.New("%T does not implement Marshal", v)
return protoiface.MarshalOutput{}, errors.New("%T does not implement Marshal", v)
}
out, err := marshaler.Marshal()
if in.Buf != nil {
out = append(in.Buf, out...)
}
return piface.MarshalOutput{
return protoiface.MarshalOutput{
Buf: out,
}, err
}
func legacyUnmarshal(in piface.UnmarshalInput) (piface.UnmarshalOutput, error) {
func legacyUnmarshal(in protoiface.UnmarshalInput) (protoiface.UnmarshalOutput, error) {
v := in.Message.(unwrapper).protoUnwrap()
unmarshaler, ok := v.(legacyUnmarshaler)
if !ok {
return piface.UnmarshalOutput{}, errors.New("%T does not implement Unmarshal", v)
return protoiface.UnmarshalOutput{}, errors.New("%T does not implement Unmarshal", v)
}
return piface.UnmarshalOutput{}, unmarshaler.Unmarshal(in.Buf)
return protoiface.UnmarshalOutput{}, unmarshaler.Unmarshal(in.Buf)
}
func legacyMerge(in piface.MergeInput) piface.MergeOutput {
func legacyMerge(in protoiface.MergeInput) protoiface.MergeOutput {
// Check whether this supports the legacy merger.
dstv := in.Destination.(unwrapper).protoUnwrap()
merger, ok := dstv.(legacyMerger)
if ok {
merger.Merge(Export{}.ProtoMessageV1Of(in.Source))
return piface.MergeOutput{Flags: piface.MergeComplete}
return protoiface.MergeOutput{Flags: protoiface.MergeComplete}
}
// If legacy merger is unavailable, implement merge in terms of
@ -433,29 +431,29 @@ func legacyMerge(in piface.MergeInput) piface.MergeOutput {
srcv := in.Source.(unwrapper).protoUnwrap()
marshaler, ok := srcv.(legacyMarshaler)
if !ok {
return piface.MergeOutput{}
return protoiface.MergeOutput{}
}
dstv = in.Destination.(unwrapper).protoUnwrap()
unmarshaler, ok := dstv.(legacyUnmarshaler)
if !ok {
return piface.MergeOutput{}
return protoiface.MergeOutput{}
}
if !in.Source.IsValid() {
// Legacy Marshal methods may not function on nil messages.
// Check for a typed nil source only after we confirm that
// legacy Marshal/Unmarshal methods are present, for
// consistency.
return piface.MergeOutput{Flags: piface.MergeComplete}
return protoiface.MergeOutput{Flags: protoiface.MergeComplete}
}
b, err := marshaler.Marshal()
if err != nil {
return piface.MergeOutput{}
return protoiface.MergeOutput{}
}
err = unmarshaler.Unmarshal(b)
if err != nil {
return piface.MergeOutput{}
return protoiface.MergeOutput{}
}
return piface.MergeOutput{Flags: piface.MergeComplete}
return protoiface.MergeOutput{Flags: protoiface.MergeComplete}
}
// aberrantMessageType implements MessageType for all types other than pointer-to-struct.
@ -463,19 +461,19 @@ type aberrantMessageType struct {
t reflect.Type
}
func (mt aberrantMessageType) New() pref.Message {
func (mt aberrantMessageType) New() protoreflect.Message {
if mt.t.Kind() == reflect.Ptr {
return aberrantMessage{reflect.New(mt.t.Elem())}
}
return aberrantMessage{reflect.Zero(mt.t)}
}
func (mt aberrantMessageType) Zero() pref.Message {
func (mt aberrantMessageType) Zero() protoreflect.Message {
return aberrantMessage{reflect.Zero(mt.t)}
}
func (mt aberrantMessageType) GoType() reflect.Type {
return mt.t
}
func (mt aberrantMessageType) Descriptor() pref.MessageDescriptor {
func (mt aberrantMessageType) Descriptor() protoreflect.MessageDescriptor {
return LegacyLoadMessageDesc(mt.t)
}
@ -499,56 +497,56 @@ func (m aberrantMessage) Reset() {
}
}
func (m aberrantMessage) ProtoReflect() pref.Message {
func (m aberrantMessage) ProtoReflect() protoreflect.Message {
return m
}
func (m aberrantMessage) Descriptor() pref.MessageDescriptor {
func (m aberrantMessage) Descriptor() protoreflect.MessageDescriptor {
return LegacyLoadMessageDesc(m.v.Type())
}
func (m aberrantMessage) Type() pref.MessageType {
func (m aberrantMessage) Type() protoreflect.MessageType {
return aberrantMessageType{m.v.Type()}
}
func (m aberrantMessage) New() pref.Message {
func (m aberrantMessage) New() protoreflect.Message {
if m.v.Type().Kind() == reflect.Ptr {
return aberrantMessage{reflect.New(m.v.Type().Elem())}
}
return aberrantMessage{reflect.Zero(m.v.Type())}
}
func (m aberrantMessage) Interface() pref.ProtoMessage {
func (m aberrantMessage) Interface() protoreflect.ProtoMessage {
return m
}
func (m aberrantMessage) Range(f func(pref.FieldDescriptor, pref.Value) bool) {
func (m aberrantMessage) Range(f func(protoreflect.FieldDescriptor, protoreflect.Value) bool) {
return
}
func (m aberrantMessage) Has(pref.FieldDescriptor) bool {
func (m aberrantMessage) Has(protoreflect.FieldDescriptor) bool {
return false
}
func (m aberrantMessage) Clear(pref.FieldDescriptor) {
func (m aberrantMessage) Clear(protoreflect.FieldDescriptor) {
panic("invalid Message.Clear on " + string(m.Descriptor().FullName()))
}
func (m aberrantMessage) Get(fd pref.FieldDescriptor) pref.Value {
func (m aberrantMessage) Get(fd protoreflect.FieldDescriptor) protoreflect.Value {
if fd.Default().IsValid() {
return fd.Default()
}
panic("invalid Message.Get on " + string(m.Descriptor().FullName()))
}
func (m aberrantMessage) Set(pref.FieldDescriptor, pref.Value) {
func (m aberrantMessage) Set(protoreflect.FieldDescriptor, protoreflect.Value) {
panic("invalid Message.Set on " + string(m.Descriptor().FullName()))
}
func (m aberrantMessage) Mutable(pref.FieldDescriptor) pref.Value {
func (m aberrantMessage) Mutable(protoreflect.FieldDescriptor) protoreflect.Value {
panic("invalid Message.Mutable on " + string(m.Descriptor().FullName()))
}
func (m aberrantMessage) NewField(pref.FieldDescriptor) pref.Value {
func (m aberrantMessage) NewField(protoreflect.FieldDescriptor) protoreflect.Value {
panic("invalid Message.NewField on " + string(m.Descriptor().FullName()))
}
func (m aberrantMessage) WhichOneof(pref.OneofDescriptor) pref.FieldDescriptor {
func (m aberrantMessage) WhichOneof(protoreflect.OneofDescriptor) protoreflect.FieldDescriptor {
panic("invalid Message.WhichOneof descriptor on " + string(m.Descriptor().FullName()))
}
func (m aberrantMessage) GetUnknown() pref.RawFields {
func (m aberrantMessage) GetUnknown() protoreflect.RawFields {
return nil
}
func (m aberrantMessage) SetUnknown(pref.RawFields) {
func (m aberrantMessage) SetUnknown(protoreflect.RawFields) {
// SetUnknown discards its input on messages which don't support unknown field storage.
}
func (m aberrantMessage) IsValid() bool {
@ -557,7 +555,7 @@ func (m aberrantMessage) IsValid() bool {
}
return false
}
func (m aberrantMessage) ProtoMethods() *piface.Methods {
func (m aberrantMessage) ProtoMethods() *protoiface.Methods {
return aberrantProtoMethods
}
func (m aberrantMessage) protoUnwrap() interface{} {

35
internal/impl/message.go
View File

@ -14,8 +14,7 @@ import (
"google.golang.org/protobuf/internal/genid"
"google.golang.org/protobuf/reflect/protoreflect"
pref "google.golang.org/protobuf/reflect/protoreflect"
preg "google.golang.org/protobuf/reflect/protoregistry"
"google.golang.org/protobuf/reflect/protoregistry"
)
// MessageInfo provides protobuf related functionality for a given Go type
@ -29,7 +28,7 @@ type MessageInfo struct {
GoReflectType reflect.Type // pointer to struct
// Desc is the underlying message descriptor type and must be populated.
Desc pref.MessageDescriptor
Desc protoreflect.MessageDescriptor
// Exporter must be provided in a purego environment in order to provide
// access to unexported fields.
@ -54,7 +53,7 @@ type exporter func(v interface{}, i int) interface{}
// is generated by our implementation of protoc-gen-go (for v2 and on).
// If it is unable to obtain a MessageInfo, it returns nil.
func getMessageInfo(mt reflect.Type) *MessageInfo {
m, ok := reflect.Zero(mt).Interface().(pref.ProtoMessage)
m, ok := reflect.Zero(mt).Interface().(protoreflect.ProtoMessage)
if !ok {
return nil
}
@ -97,7 +96,7 @@ func (mi *MessageInfo) initOnce() {
// getPointer returns the pointer for a message, which should be of
// the type of the MessageInfo. If the message is of a different type,
// it returns ok==false.
func (mi *MessageInfo) getPointer(m pref.Message) (p pointer, ok bool) {
func (mi *MessageInfo) getPointer(m protoreflect.Message) (p pointer, ok bool) {
switch m := m.(type) {
case *messageState:
return m.pointer(), m.messageInfo() == mi
@ -134,10 +133,10 @@ type structInfo struct {
extensionOffset offset
extensionType reflect.Type
fieldsByNumber map[pref.FieldNumber]reflect.StructField
oneofsByName map[pref.Name]reflect.StructField
oneofWrappersByType map[reflect.Type]pref.FieldNumber
oneofWrappersByNumber map[pref.FieldNumber]reflect.Type
fieldsByNumber map[protoreflect.FieldNumber]reflect.StructField
oneofsByName map[protoreflect.Name]reflect.StructField
oneofWrappersByType map[reflect.Type]protoreflect.FieldNumber
oneofWrappersByNumber map[protoreflect.FieldNumber]reflect.Type
}
func (mi *MessageInfo) makeStructInfo(t reflect.Type) structInfo {
@ -147,10 +146,10 @@ func (mi *MessageInfo) makeStructInfo(t reflect.Type) structInfo {
unknownOffset: invalidOffset,
extensionOffset: invalidOffset,
fieldsByNumber: map[pref.FieldNumber]reflect.StructField{},
oneofsByName: map[pref.Name]reflect.StructField{},
oneofWrappersByType: map[reflect.Type]pref.FieldNumber{},
oneofWrappersByNumber: map[pref.FieldNumber]reflect.Type{},
fieldsByNumber: map[protoreflect.FieldNumber]reflect.StructField{},
oneofsByName: map[protoreflect.Name]reflect.StructField{},
oneofWrappersByType: map[reflect.Type]protoreflect.FieldNumber{},
oneofWrappersByNumber: map[protoreflect.FieldNumber]reflect.Type{},
}
fieldLoop:
@ -180,12 +179,12 @@ fieldLoop:
for _, s := range strings.Split(f.Tag.Get("protobuf"), ",") {
if len(s) > 0 && strings.Trim(s, "0123456789") == "" {
n, _ := strconv.ParseUint(s, 10, 64)
si.fieldsByNumber[pref.FieldNumber(n)] = f
si.fieldsByNumber[protoreflect.FieldNumber(n)] = f
continue fieldLoop
}
}
if s := f.Tag.Get("protobuf_oneof"); len(s) > 0 {
si.oneofsByName[pref.Name(s)] = f
si.oneofsByName[protoreflect.Name(s)] = f
continue fieldLoop
}
}
@ -208,8 +207,8 @@ fieldLoop:
for _, s := range strings.Split(f.Tag.Get("protobuf"), ",") {
if len(s) > 0 && strings.Trim(s, "0123456789") == "" {
n, _ := strconv.ParseUint(s, 10, 64)
si.oneofWrappersByType[tf] = pref.FieldNumber(n)
si.oneofWrappersByNumber[pref.FieldNumber(n)] = tf
si.oneofWrappersByType[tf] = protoreflect.FieldNumber(n)
si.oneofWrappersByNumber[protoreflect.FieldNumber(n)] = tf
break
}
}
@ -237,7 +236,7 @@ func (mi *MessageInfo) Message(i int) protoreflect.MessageType {
fd := mi.Desc.Fields().Get(i)
switch {
case fd.IsWeak():
mt, _ := preg.GlobalTypes.FindMessageByName(fd.Message().FullName())
mt, _ := protoregistry.GlobalTypes.FindMessageByName(fd.Message().FullName())
return mt
case fd.IsMap():
return mapEntryType{fd.Message(), mi.fieldTypes[fd.Number()]}

19
internal/order/order_test.go
View File

@ -11,7 +11,6 @@ import (
"github.com/google/go-cmp/cmp"
"google.golang.org/protobuf/reflect/protoreflect"
pref "google.golang.org/protobuf/reflect/protoreflect"
)
type fieldDesc struct {
@ -20,15 +19,15 @@ type fieldDesc struct {
number protoreflect.FieldNumber
extension bool
oneofIndex int // non-zero means within oneof; negative means synthetic
pref.FieldDescriptor
protoreflect.FieldDescriptor
}
func (d fieldDesc) Index() int { return d.index }
func (d fieldDesc) Name() pref.Name { return d.name.Name() }
func (d fieldDesc) FullName() pref.FullName { return d.name }
func (d fieldDesc) Number() pref.FieldNumber { return d.number }
func (d fieldDesc) IsExtension() bool { return d.extension }
func (d fieldDesc) ContainingOneof() pref.OneofDescriptor {
func (d fieldDesc) Index() int { return d.index }
func (d fieldDesc) Name() protoreflect.Name { return d.name.Name() }
func (d fieldDesc) FullName() protoreflect.FullName { return d.name }
func (d fieldDesc) Number() protoreflect.FieldNumber { return d.number }
func (d fieldDesc) IsExtension() bool { return d.extension }
func (d fieldDesc) ContainingOneof() protoreflect.OneofDescriptor {
switch {
case d.oneofIndex < 0:
return oneofDesc{index: -d.oneofIndex, synthetic: true}
@ -42,7 +41,7 @@ func (d fieldDesc) ContainingOneof() pref.OneofDescriptor {
type oneofDesc struct {
index int
synthetic bool
pref.OneofDescriptor
protoreflect.OneofDescriptor
}
func (d oneofDesc) Index() int { return d.index }
@ -158,7 +157,7 @@ func TestKeyOrder(t *testing.T) {
t.Run(tt.label, func(t *testing.T) {
var got, want []protoreflect.MapKey
for _, v := range tt.keys {
want = append(want, pref.ValueOf(v).MapKey())
want = append(want, protoreflect.ValueOf(v).MapKey())
}
got = append(got, want...)
for i, j := range rand.Perm(len(got)) {

13
proto/extension_test.go
View File

@ -14,7 +14,6 @@ import (
"google.golang.org/protobuf/proto"
"google.golang.org/protobuf/reflect/protoreflect"
pref "google.golang.org/protobuf/reflect/protoreflect"
"google.golang.org/protobuf/runtime/protoimpl"
"google.golang.org/protobuf/testing/protocmp"
@ -27,7 +26,7 @@ import (
func TestExtensionFuncs(t *testing.T) {
for _, test := range []struct {
message proto.Message
ext pref.ExtensionType
ext protoreflect.ExtensionType
wantDefault interface{}
value interface{}
}{
@ -209,10 +208,10 @@ func TestIsValid(t *testing.T) {
func TestExtensionRanger(t *testing.T) {
tests := []struct {
msg proto.Message
want map[pref.ExtensionType]interface{}
want map[protoreflect.ExtensionType]interface{}
}{{
msg: &testpb.TestAllExtensions{},
want: map[pref.ExtensionType]interface{}{
want: map[protoreflect.ExtensionType]interface{}{
testpb.E_OptionalInt32: int32(5),
testpb.E_OptionalString: string("hello"),
testpb.E_OptionalNestedMessage: &testpb.TestAllExtensions_NestedMessage{},
@ -223,7 +222,7 @@ func TestExtensionRanger(t *testing.T) {
},
}, {
msg: &descpb.MessageOptions{},
want: map[pref.ExtensionType]interface{}{
want: map[protoreflect.ExtensionType]interface{}{
test3pb.E_OptionalInt32: int32(5),
test3pb.E_OptionalString: string("hello"),
test3pb.E_OptionalForeignMessage: &test3pb.ForeignMessage{},
@ -241,8 +240,8 @@ func TestExtensionRanger(t *testing.T) {
proto.SetExtension(tt.msg, xt, v)
}
got := make(map[pref.ExtensionType]interface{})
proto.RangeExtensions(tt.msg, func(xt pref.ExtensionType, v interface{}) bool {
got := make(map[protoreflect.ExtensionType]interface{})
proto.RangeExtensions(tt.msg, func(xt protoreflect.ExtensionType, v interface{}) bool {
got[xt] = v
return true
})

7
testing/protopack/pack_test.go
View File

@ -14,14 +14,13 @@ import (
"github.com/google/go-cmp/cmp"
"google.golang.org/protobuf/encoding/prototext"
pdesc "google.golang.org/protobuf/reflect/protodesc"
"google.golang.org/protobuf/reflect/protodesc"
"google.golang.org/protobuf/reflect/protoreflect"
pref "google.golang.org/protobuf/reflect/protoreflect"
"google.golang.org/protobuf/types/descriptorpb"
)
var msgDesc = func() pref.MessageDescriptor {
var msgDesc = func() protoreflect.MessageDescriptor {
const s = `
name: "test.proto"
syntax: "proto2"
@ -50,7 +49,7 @@ var msgDesc = func() pref.MessageDescriptor {
if err := prototext.Unmarshal([]byte(s), pb); err != nil {
panic(err)
}
fd, err := pdesc.NewFile(pb, nil)
fd, err := protodesc.NewFile(pb, nil)
if err != nil {
panic(err)
}

239
testing/prototest/message.go
View File

@ -18,7 +18,6 @@ import (
"google.golang.org/protobuf/encoding/protowire"
"google.golang.org/protobuf/proto"
"google.golang.org/protobuf/reflect/protoreflect"
pref "google.golang.org/protobuf/reflect/protoreflect"
"google.golang.org/protobuf/reflect/protoregistry"
)
@ -30,14 +29,14 @@ type Message struct {
// Resolver is used to determine the list of extension fields to test with.
// If nil, this defaults to using protoregistry.GlobalTypes.
Resolver interface {
FindExtensionByName(field pref.FullName) (pref.ExtensionType, error)
FindExtensionByNumber(message pref.FullName, field pref.FieldNumber) (pref.ExtensionType, error)
RangeExtensionsByMessage(message pref.FullName, f func(pref.ExtensionType) bool)
FindExtensionByName(field protoreflect.FullName) (protoreflect.ExtensionType, error)
FindExtensionByNumber(message protoreflect.FullName, field protoreflect.FieldNumber) (protoreflect.ExtensionType, error)
RangeExtensionsByMessage(message protoreflect.FullName, f func(protoreflect.ExtensionType) bool)
}
}
// Test performs tests on a MessageType implementation.
func (test Message) Test(t testing.TB, mt pref.MessageType) {
func (test Message) Test(t testing.TB, mt protoreflect.MessageType) {
testType(t, mt)
md := mt.Descriptor()
@ -49,8 +48,8 @@ func (test Message) Test(t testing.TB, mt pref.MessageType) {
if test.Resolver == nil {
test.Resolver = protoregistry.GlobalTypes
}
var extTypes []pref.ExtensionType
test.Resolver.RangeExtensionsByMessage(md.FullName(), func(e pref.ExtensionType) bool {
var extTypes []protoreflect.ExtensionType
test.Resolver.RangeExtensionsByMessage(md.FullName(), func(e protoreflect.ExtensionType) bool {
extTypes = append(extTypes, e)
return true
})
@ -86,7 +85,7 @@ func (test Message) Test(t testing.TB, mt pref.MessageType) {
}
}
func testType(t testing.TB, mt pref.MessageType) {
func testType(t testing.TB, mt protoreflect.MessageType) {
m := mt.New().Interface()
want := reflect.TypeOf(m)
if got := reflect.TypeOf(m.ProtoReflect().Interface()); got != want {
@ -98,19 +97,19 @@ func testType(t testing.TB, mt pref.MessageType) {
if got := reflect.TypeOf(m.ProtoReflect().Type().Zero().Interface()); got != want {
t.Errorf("type mismatch: reflect.TypeOf(m) != reflect.TypeOf(m.ProtoReflect().Type().Zero().Interface()): %v != %v", got, want)
}
if mt, ok := mt.(pref.MessageFieldTypes); ok {
if mt, ok := mt.(protoreflect.MessageFieldTypes); ok {
testFieldTypes(t, mt)
}
}
func testFieldTypes(t testing.TB, mt pref.MessageFieldTypes) {
descName := func(d pref.Descriptor) pref.FullName {
func testFieldTypes(t testing.TB, mt protoreflect.MessageFieldTypes) {
descName := func(d protoreflect.Descriptor) protoreflect.FullName {
if d == nil {
return "<nil>"
}
return d.FullName()
}
typeName := func(mt pref.MessageType) pref.FullName {
typeName := func(mt protoreflect.MessageType) protoreflect.FullName {
if mt == nil {
return "<nil>"
}
@ -173,7 +172,7 @@ func testFieldTypes(t testing.TB, mt pref.MessageFieldTypes) {
checkMessageDesc(i,
"mti.Descriptor()", "fd.Message()",
mti.Descriptor(), fd.Message())
if mti := mti.(pref.MessageFieldTypes); mti != nil {
if mti := mti.(protoreflect.MessageFieldTypes); mti != nil {
if fd.MapValue().Enum() != nil {
checkEnumDesc(i,
"mti.Enum(fd.MapValue().Index()).Descriptor()", "fd.MapValue().Enum()",
@ -207,7 +206,7 @@ func testFieldTypes(t testing.TB, mt pref.MessageFieldTypes) {
}
// testField exercises set/get/has/clear of a field.
func testField(t testing.TB, m pref.Message, fd pref.FieldDescriptor) {
func testField(t testing.TB, m protoreflect.Message, fd protoreflect.FieldDescriptor) {
name := fd.FullName()
num := fd.Number()
@ -221,7 +220,7 @@ func testField(t testing.TB, m pref.Message, fd pref.FieldDescriptor) {
if got, want := m.NewField(fd), fd.Default(); !valueEqual(got, want) {
t.Errorf("Message.NewField(%v) = %v, want default value %v", name, formatValue(got), formatValue(want))
}
if fd.Kind() == pref.FloatKind || fd.Kind() == pref.DoubleKind {
if fd.Kind() == protoreflect.FloatKind || fd.Kind() == protoreflect.DoubleKind {
testFieldFloat(t, m, fd)
}
}
@ -232,20 +231,20 @@ func testField(t testing.TB, m pref.Message, fd pref.FieldDescriptor) {
m.Set(fd, v)
wantHas := true
if n == 0 {
if fd.Syntax() == pref.Proto3 && fd.Message() == nil {
if fd.Syntax() == protoreflect.Proto3 && fd.Message() == nil {
wantHas = false
}
if fd.IsExtension() {
wantHas = true
}
if fd.Cardinality() == pref.Repeated {
if fd.Cardinality() == protoreflect.Repeated {
wantHas = false
}
if fd.ContainingOneof() != nil {
wantHas = true
}
}
if fd.Syntax() == pref.Proto3 && fd.Cardinality() != pref.Repeated && fd.ContainingOneof() == nil && fd.Kind() == pref.EnumKind && v.Enum() == 0 {
if fd.Syntax() == protoreflect.Proto3 && fd.Cardinality() != protoreflect.Repeated && fd.ContainingOneof() == nil && fd.Kind() == protoreflect.EnumKind && v.Enum() == 0 {
wantHas = false
}
if got, want := m.Has(fd), wantHas; got != want {
@ -255,7 +254,7 @@ func testField(t testing.TB, m pref.Message, fd pref.FieldDescriptor) {
t.Errorf("after setting %q:\nMessage.Get(%v) = %v, want %v", name, num, formatValue(got), formatValue(want))
}
found := false
m.Range(func(d pref.FieldDescriptor, got pref.Value) bool {
m.Range(func(d protoreflect.FieldDescriptor, got protoreflect.Value) bool {
if fd != d {
return true
}
@ -293,7 +292,7 @@ func testField(t testing.TB, m pref.Message, fd pref.FieldDescriptor) {
switch {
case fd.IsList() || fd.IsMap():
m.Set(fd, m.Mutable(fd))
if got, want := m.Has(fd), (fd.IsExtension() && fd.Cardinality() != pref.Repeated) || fd.ContainingOneof() != nil; got != want {
if got, want := m.Has(fd), (fd.IsExtension() && fd.Cardinality() != protoreflect.Repeated) || fd.ContainingOneof() != nil; got != want {
t.Errorf("after setting %q to default:\nMessage.Has(%v) = %v, want %v", name, num, got, want)
}
case fd.Message() == nil:
@ -305,9 +304,9 @@ func testField(t testing.TB, m pref.Message, fd pref.FieldDescriptor) {
m.Clear(fd)
// Set to the wrong type.
v := pref.ValueOfString("")
if fd.Kind() == pref.StringKind {
v = pref.ValueOfInt32(0)
v := protoreflect.ValueOfString("")
if fd.Kind() == protoreflect.StringKind {
v = protoreflect.ValueOfInt32(0)
}
if !panics(func() {
m.Set(fd, v)
@ -317,7 +316,7 @@ func testField(t testing.TB, m pref.Message, fd pref.FieldDescriptor) {
}
// testFieldMap tests set/get/has/clear of entries in a map field.
func testFieldMap(t testing.TB, m pref.Message, fd pref.FieldDescriptor) {
func testFieldMap(t testing.TB, m protoreflect.Message, fd protoreflect.FieldDescriptor) {
name := fd.FullName()
num := fd.Number()
@ -331,7 +330,7 @@ func testFieldMap(t testing.TB, m pref.Message, fd pref.FieldDescriptor) {
t.Errorf("message.Get(%v).NewValue() = %v, want %v", name, formatValue(got), formatValue(want))
}
if !panics(func() {
m.Set(fd, pref.ValueOfMap(mapv))
m.Set(fd, protoreflect.ValueOfMap(mapv))
}) {
t.Errorf("message.Set(%v, <invalid>) does not panic", name)
}
@ -359,36 +358,36 @@ func testFieldMap(t testing.TB, m pref.Message, fd pref.FieldDescriptor) {
v := newMapValue(fd, mapv, n, nil)
mapv.Set(k, v)
want.Set(k, v)
if got, want := m.Get(fd), pref.ValueOfMap(want); !valueEqual(got, want) {
if got, want := m.Get(fd), protoreflect.ValueOfMap(want); !valueEqual(got, want) {
t.Errorf("after inserting %d elements to %q:\nMessage.Get(%v) = %v, want %v", i, name, num, formatValue(got), formatValue(want))
}
}
// Set values.
want.Range(func(k pref.MapKey, v pref.Value) bool {
want.Range(func(k protoreflect.MapKey, v protoreflect.Value) bool {
nv := newMapValue(fd, mapv, 10, nil)
mapv.Set(k, nv)
want.Set(k, nv)
if got, want := m.Get(fd), pref.ValueOfMap(want); !valueEqual(got, want) {
if got, want := m.Get(fd), protoreflect.ValueOfMap(want); !valueEqual(got, want) {
t.Errorf("after setting element %v of %q:\nMessage.Get(%v) = %v, want %v", formatValue(k.Value()), name, num, formatValue(got), formatValue(want))
}
return true
})
// Clear values.
want.Range(func(k pref.MapKey, v pref.Value) bool {
want.Range(func(k protoreflect.MapKey, v protoreflect.Value) bool {
mapv.Clear(k)
want.Clear(k)
if got, want := m.Has(fd), want.Len() > 0; got != want {
t.Errorf("after clearing elements of %q:\nMessage.Has(%v) = %v, want %v", name, num, got, want)
}
if got, want := m.Get(fd), pref.ValueOfMap(want); !valueEqual(got, want) {
if got, want := m.Get(fd), protoreflect.ValueOfMap(want); !valueEqual(got, want) {
t.Errorf("after clearing elements of %q:\nMessage.Get(%v) = %v, want %v", name, num, formatValue(got), formatValue(want))
}
return true
})
if mapv := m.Get(fd).Map(); mapv.IsValid() {
t.Errorf("after clearing all elements: message.Get(%v).IsValid() = true, want false %v", name, formatValue(pref.ValueOfMap(mapv)))
t.Errorf("after clearing all elements: message.Get(%v).IsValid() = true, want false %v", name, formatValue(protoreflect.ValueOfMap(mapv)))
}
// Non-existent map keys.
@ -422,18 +421,18 @@ func testFieldMap(t testing.TB, m pref.Message, fd pref.FieldDescriptor) {
}
}
type testMap map[interface{}]pref.Value
type testMap map[interface{}]protoreflect.Value
func (m testMap) Get(k pref.MapKey) pref.Value { return m[k.Interface()] }
func (m testMap) Set(k pref.MapKey, v pref.Value) { m[k.Interface()] = v }
func (m testMap) Has(k pref.MapKey) bool { return m.Get(k).IsValid() }
func (m testMap) Clear(k pref.MapKey) { delete(m, k.Interface()) }
func (m testMap) Mutable(k pref.MapKey) pref.Value { panic("unimplemented") }
func (m testMap) Len() int { return len(m) }
func (m testMap) NewValue() pref.Value { panic("unimplemented") }
func (m testMap) Range(f func(pref.MapKey, pref.Value) bool) {
func (m testMap) Get(k protoreflect.MapKey) protoreflect.Value { return m[k.Interface()] }
func (m testMap) Set(k protoreflect.MapKey, v protoreflect.Value) { m[k.Interface()] = v }
func (m testMap) Has(k protoreflect.MapKey) bool { return m.Get(k).IsValid() }
func (m testMap) Clear(k protoreflect.MapKey) { delete(m, k.Interface()) }
func (m testMap) Mutable(k protoreflect.MapKey) protoreflect.Value { panic("unimplemented") }
func (m testMap) Len() int { return len(m) }
func (m testMap) NewValue() protoreflect.Value { panic("unimplemented") }
func (m testMap) Range(f func(protoreflect.MapKey, protoreflect.Value) bool) {
for k, v := range m {
if !f(pref.ValueOf(k).MapKey(), v) {
if !f(protoreflect.ValueOf(k).MapKey(), v) {
return
}
}
@ -441,7 +440,7 @@ func (m testMap) Range(f func(pref.MapKey, pref.Value) bool) {
func (m testMap) IsValid() bool { return true }
// testFieldList exercises set/get/append/truncate of values in a list.
func testFieldList(t testing.TB, m pref.Message, fd pref.FieldDescriptor) {
func testFieldList(t testing.TB, m protoreflect.Message, fd protoreflect.FieldDescriptor) {
name := fd.FullName()
num := fd.Number()
@ -451,7 +450,7 @@ func testFieldList(t testing.TB, m pref.Message, fd pref.FieldDescriptor) {
t.Errorf("message.Get(%v).IsValid() = true, want false", name)
}
if !panics(func() {
m.Set(fd, pref.ValueOfList(list))
m.Set(fd, protoreflect.ValueOfList(list))
}) {
t.Errorf("message.Set(%v, <invalid>) does not panic", name)
}
@ -472,7 +471,7 @@ func testFieldList(t testing.TB, m pref.Message, fd pref.FieldDescriptor) {
}
// Append values.
var want pref.List = &testList{}
var want protoreflect.List = &testList{}
for i, n := range []seed{1, 0, minVal, maxVal} {
if got, want := m.Has(fd), i > 0; got != want {
t.Errorf("after appending %d elements to %q:\nMessage.Has(%v) = %v, want %v", i, name, num, got, want)
@ -481,7 +480,7 @@ func testFieldList(t testing.TB, m pref.Message, fd pref.FieldDescriptor) {
want.Append(v)
list.Append(v)
if got, want := m.Get(fd), pref.ValueOfList(want); !valueEqual(got, want) {
if got, want := m.Get(fd), protoreflect.ValueOfList(want); !valueEqual(got, want) {
t.Errorf("after appending %d elements to %q:\nMessage.Get(%v) = %v, want %v", i+1, name, num, formatValue(got), formatValue(want))
}
}
@ -491,7 +490,7 @@ func testFieldList(t testing.TB, m pref.Message, fd pref.FieldDescriptor) {
v := newListElement(fd, list, seed(i+10), nil)
want.Set(i, v)
list.Set(i, v)
if got, want := m.Get(fd), pref.ValueOfList(want); !valueEqual(got, want) {
if got, want := m.Get(fd), protoreflect.ValueOfList(want); !valueEqual(got, want) {
t.Errorf("after setting element %d of %q:\nMessage.Get(%v) = %v, want %v", i, name, num, formatValue(got), formatValue(want))
}
}
@ -504,7 +503,7 @@ func testFieldList(t testing.TB, m pref.Message, fd pref.FieldDescriptor) {
if got, want := m.Has(fd), want.Len() > 0; got != want {
t.Errorf("after truncating %q to %d:\nMessage.Has(%v) = %v, want %v", name, n, num, got, want)
}
if got, want := m.Get(fd), pref.ValueOfList(want); !valueEqual(got, want) {
if got, want := m.Get(fd), protoreflect.ValueOfList(want); !valueEqual(got, want) {
t.Errorf("after truncating %q to %d:\nMessage.Get(%v) = %v, want %v", name, n, num, formatValue(got), formatValue(want))
}
}
@ -530,29 +529,29 @@ func testFieldList(t testing.TB, m pref.Message, fd pref.FieldDescriptor) {
}
type testList struct {
a []pref.Value
a []protoreflect.Value
}
func (l *testList) Append(v pref.Value) { l.a = append(l.a, v) }
func (l *testList) AppendMutable() pref.Value { panic("unimplemented") }
func (l *testList) Get(n int) pref.Value { return l.a[n] }
func (l *testList) Len() int { return len(l.a) }
func (l *testList) Set(n int, v pref.Value) { l.a[n] = v }
func (l *testList) Truncate(n int) { l.a = l.a[:n] }
func (l *testList) NewElement() pref.Value { panic("unimplemented") }
func (l *testList) IsValid() bool { return true }
func (l *testList) Append(v protoreflect.Value) { l.a = append(l.a, v) }
func (l *testList) AppendMutable() protoreflect.Value { panic("unimplemented") }
func (l *testList) Get(n int) protoreflect.Value { return l.a[n] }
func (l *testList) Len() int { return len(l.a) }
func (l *testList) Set(n int, v protoreflect.Value) { l.a[n] = v }
func (l *testList) Truncate(n int) { l.a = l.a[:n] }
func (l *testList) NewElement() protoreflect.Value { panic("unimplemented") }
func (l *testList) IsValid() bool { return true }
// testFieldFloat exercises some interesting floating-point scalar field values.
func testFieldFloat(t testing.TB, m pref.Message, fd pref.FieldDescriptor) {
func testFieldFloat(t testing.TB, m protoreflect.Message, fd protoreflect.FieldDescriptor) {
name := fd.FullName()
num := fd.Number()
for _, v := range []float64{math.Inf(-1), math.Inf(1), math.NaN(), math.Copysign(0, -1)} {
var val pref.Value
if fd.Kind() == pref.FloatKind {
val = pref.ValueOfFloat32(float32(v))
var val protoreflect.Value
if fd.Kind() == protoreflect.FloatKind {
val = protoreflect.ValueOfFloat32(float32(v))
} else {
val = pref.ValueOfFloat64(float64(v))
val = protoreflect.ValueOfFloat64(float64(v))
}
m.Set(fd, val)
// Note that Has is true for -0.
@ -566,7 +565,7 @@ func testFieldFloat(t testing.TB, m pref.Message, fd pref.FieldDescriptor) {
}
// testOneof tests the behavior of fields in a oneof.
func testOneof(t testing.TB, m pref.Message, od pref.OneofDescriptor) {
func testOneof(t testing.TB, m protoreflect.Message, od protoreflect.OneofDescriptor) {
for _, mutable := range []bool{false, true} {
for i := 0; i < od.Fields().Len(); i++ {
fda := od.Fields().Get(i)
@ -594,19 +593,19 @@ func testOneof(t testing.TB, m pref.Message, od pref.OneofDescriptor) {
}
// testUnknown tests the behavior of unknown fields.
func testUnknown(t testing.TB, m pref.Message) {
func testUnknown(t testing.TB, m protoreflect.Message) {
var b []byte
b = protowire.AppendTag(b, 1000, protowire.VarintType)
b = protowire.AppendVarint(b, 1001)
m.SetUnknown(pref.RawFields(b))
m.SetUnknown(protoreflect.RawFields(b))
if got, want := []byte(m.GetUnknown()), b; !bytes.Equal(got, want) {
t.Errorf("after setting unknown fields:\nGetUnknown() = %v, want %v", got, want)
}
}
func formatValue(v pref.Value) string {
func formatValue(v protoreflect.Value) string {
switch v := v.Interface().(type) {
case pref.List:
case protoreflect.List:
var buf bytes.Buffer
buf.WriteString("list[")
for i := 0; i < v.Len(); i++ {
@ -617,11 +616,11 @@ func formatValue(v pref.Value) string {
}
buf.WriteString("]")
return buf.String()
case pref.Map:
case protoreflect.Map:
var buf bytes.Buffer
buf.WriteString("map[")
var keys []pref.MapKey
v.Range(func(k pref.MapKey, v pref.Value) bool {
var keys []protoreflect.MapKey
v.Range(func(k protoreflect.MapKey, v protoreflect.Value) bool {
keys = append(keys, k)
return true
})
@ -638,7 +637,7 @@ func formatValue(v pref.Value) string {
}
buf.WriteString("]")
return buf.String()
case pref.Message:
case protoreflect.Message:
b, err := prototext.Marshal(v.Interface())
if err != nil {
return fmt.Sprintf("<%v>", err)
@ -651,15 +650,15 @@ func formatValue(v pref.Value) string {
}
}
func valueEqual(a, b pref.Value) bool {
func valueEqual(a, b protoreflect.Value) bool {
ai, bi := a.Interface(), b.Interface()
switch ai.(type) {
case pref.Message:
case protoreflect.Message:
return proto.Equal(
a.Message().Interface(),
b.Message().Interface(),
)
case pref.List:
case protoreflect.List:
lista, listb := a.List(), b.List()
if lista.Len() != listb.Len() {
return false
@ -670,13 +669,13 @@ func valueEqual(a, b pref.Value) bool {
}
}
return true
case pref.Map:
case protoreflect.Map:
mapa, mapb := a.Map(), b.Map()
if mapa.Len() != mapb.Len() {
return false
}
equal := true
mapa.Range(func(k pref.MapKey, v pref.Value) bool {
mapa.Range(func(k protoreflect.MapKey, v protoreflect.Value) bool {
if !valueEqual(v, mapb.Get(k)) {
equal = false
return false
@ -727,7 +726,7 @@ func newSeed(n seed, adjust ...int) seed {
//
// The stack parameter is used to avoid infinite recursion when populating circular
// data structures.
func newValue(m pref.Message, fd pref.FieldDescriptor, n seed, stack []pref.MessageDescriptor) pref.Value {
func newValue(m protoreflect.Message, fd protoreflect.FieldDescriptor, n seed, stack []protoreflect.MessageDescriptor) protoreflect.Value {
switch {
case fd.IsList():
if n == 0 {
@ -738,7 +737,7 @@ func newValue(m pref.Message, fd pref.FieldDescriptor, n seed, stack []pref.Mess
list.Append(newListElement(fd, list, minVal, stack))
list.Append(newListElement(fd, list, maxVal, stack))
list.Append(newListElement(fd, list, n, stack))
return pref.ValueOfList(list)
return protoreflect.ValueOfList(list)
case fd.IsMap():
if n == 0 {
return m.New().Mutable(fd)
@ -748,7 +747,7 @@ func newValue(m pref.Message, fd pref.FieldDescriptor, n seed, stack []pref.Mess
mapv.Set(newMapKey(fd, minVal), newMapValue(fd, mapv, minVal, stack))
mapv.Set(newMapKey(fd, maxVal), newMapValue(fd, mapv, maxVal, stack))
mapv.Set(newMapKey(fd, n), newMapValue(fd, mapv, newSeed(n, 0), stack))
return pref.ValueOfMap(mapv)
return protoreflect.ValueOfMap(mapv)
case fd.Message() != nil:
return populateMessage(m.NewField(fd).Message(), n, stack)
default:
@ -756,19 +755,19 @@ func newValue(m pref.Message, fd pref.FieldDescriptor, n seed, stack []pref.Mess
}
}
func newListElement(fd pref.FieldDescriptor, list pref.List, n seed, stack []pref.MessageDescriptor) pref.Value {
func newListElement(fd protoreflect.FieldDescriptor, list protoreflect.List, n seed, stack []protoreflect.MessageDescriptor) protoreflect.Value {
if fd.Message() == nil {
return newScalarValue(fd, n)
}
return populateMessage(list.NewElement().Message(), n, stack)
}
func newMapKey(fd pref.FieldDescriptor, n seed) pref.MapKey {
func newMapKey(fd protoreflect.FieldDescriptor, n seed) protoreflect.MapKey {
kd := fd.MapKey()
return newScalarValue(kd, n).MapKey()
}
func newMapValue(fd pref.FieldDescriptor, mapv pref.Map, n seed, stack []pref.MessageDescriptor) pref.Value {
func newMapValue(fd protoreflect.FieldDescriptor, mapv protoreflect.Map, n seed, stack []protoreflect.MessageDescriptor) protoreflect.Value {
vd := fd.MapValue()
if vd.Message() == nil {
return newScalarValue(vd, n)
@ -776,11 +775,11 @@ func newMapValue(fd pref.FieldDescriptor, mapv pref.Map, n seed, stack []pref.Me
return populateMessage(mapv.NewValue().Message(), n, stack)
}
func newScalarValue(fd pref.FieldDescriptor, n seed) pref.Value {
func newScalarValue(fd protoreflect.FieldDescriptor, n seed) protoreflect.Value {
switch fd.Kind() {
case pref.BoolKind:
return pref.ValueOfBool(n != 0)
case pref.EnumKind:
case protoreflect.BoolKind:
return protoreflect.ValueOfBool(n != 0)
case protoreflect.EnumKind:
vals := fd.Enum().Values()
var i int
switch n {
@ -791,85 +790,85 @@ func newScalarValue(fd pref.FieldDescriptor, n seed) pref.Value {
default:
i = int(n) % vals.Len()
}
return pref.ValueOfEnum(vals.Get(i).Number())
case pref.Int32Kind, pref.Sint32Kind, pref.Sfixed32Kind:
return protoreflect.ValueOfEnum(vals.Get(i).Number())
case protoreflect.Int32Kind, protoreflect.Sint32Kind, protoreflect.Sfixed32Kind:
switch n {
case minVal:
return pref.ValueOfInt32(math.MinInt32)
return protoreflect.ValueOfInt32(math.MinInt32)
case maxVal:
return pref.ValueOfInt32(math.MaxInt32)
return protoreflect.ValueOfInt32(math.MaxInt32)
default:
return pref.ValueOfInt32(int32(n))
return protoreflect.ValueOfInt32(int32(n))
}
case pref.Uint32Kind, pref.Fixed32Kind:
case protoreflect.Uint32Kind, protoreflect.Fixed32Kind:
switch n {
case minVal:
// Only use 0 for the zero value.
return pref.ValueOfUint32(1)
return protoreflect.ValueOfUint32(1)
case maxVal:
return pref.ValueOfUint32(math.MaxInt32)
return protoreflect.ValueOfUint32(math.MaxInt32)
default:
return pref.ValueOfUint32(uint32(n))
return protoreflect.ValueOfUint32(uint32(n))
}
case pref.Int64Kind, pref.Sint64Kind, pref.Sfixed64Kind:
case protoreflect.Int64Kind, protoreflect.Sint64Kind, protoreflect.Sfixed64Kind:
switch n {
case minVal:
return pref.ValueOfInt64(math.MinInt64)
return protoreflect.ValueOfInt64(math.MinInt64)
case maxVal:
return pref.ValueOfInt64(math.MaxInt64)
return protoreflect.ValueOfInt64(math.MaxInt64)
default:
return pref.ValueOfInt64(int64(n))
return protoreflect.ValueOfInt64(int64(n))
}
case pref.Uint64Kind, pref.Fixed64Kind:
case protoreflect.Uint64Kind, protoreflect.Fixed64Kind:
switch n {
case minVal:
// Only use 0 for the zero value.
return pref.ValueOfUint64(1)
return protoreflect.ValueOfUint64(1)
case maxVal:
return pref.ValueOfUint64(math.MaxInt64)
return protoreflect.ValueOfUint64(math.MaxInt64)
default:
return pref.ValueOfUint64(uint64(n))
return protoreflect.ValueOfUint64(uint64(n))
}
case pref.FloatKind:
case protoreflect.FloatKind:
switch n {
case minVal:
return pref.ValueOfFloat32(math.SmallestNonzeroFloat32)
return protoreflect.ValueOfFloat32(math.SmallestNonzeroFloat32)
case maxVal:
return pref.ValueOfFloat32(math.MaxFloat32)
return protoreflect.ValueOfFloat32(math.MaxFloat32)
default:
return pref.ValueOfFloat32(1.5 * float32(n))
return protoreflect.ValueOfFloat32(1.5 * float32(n))
}
case pref.DoubleKind:
case protoreflect.DoubleKind:
switch n {
case minVal:
return pref.ValueOfFloat64(math.SmallestNonzeroFloat64)
return protoreflect.ValueOfFloat64(math.SmallestNonzeroFloat64)
case maxVal:
return pref.ValueOfFloat64(math.MaxFloat64)
return protoreflect.ValueOfFloat64(math.MaxFloat64)
default:
return pref.ValueOfFloat64(1.5 * float64(n))
return protoreflect.ValueOfFloat64(1.5 * float64(n))
}
case pref.StringKind:
case protoreflect.StringKind:
if n == 0 {
return pref.ValueOfString("")
return protoreflect.ValueOfString("")
}
return pref.ValueOfString(fmt.Sprintf("%d", n))
case pref.BytesKind:
return protoreflect.ValueOfString(fmt.Sprintf("%d", n))
case protoreflect.BytesKind:
if n == 0 {
return pref.ValueOfBytes(nil)
return protoreflect.ValueOfBytes(nil)
}
return pref.ValueOfBytes([]byte{byte(n >> 24), byte(n >> 16), byte(n >> 8), byte(n)})
return protoreflect.ValueOfBytes([]byte{byte(n >> 24), byte(n >> 16), byte(n >> 8), byte(n)})
}
panic("unhandled kind")
}
func populateMessage(m pref.Message, n seed, stack []pref.MessageDescriptor) pref.Value {
func populateMessage(m protoreflect.Message, n seed, stack []protoreflect.MessageDescriptor) protoreflect.Value {
if n == 0 {
return pref.ValueOfMessage(m)
return protoreflect.ValueOfMessage(m)
}
md := m.Descriptor()
for _, x := range stack {
if md == x {
return pref.ValueOfMessage(m)
return protoreflect.ValueOfMessage(m)
}
}
stack = append(stack, md)
@ -880,7 +879,7 @@ func populateMessage(m pref.Message, n seed, stack []pref.MessageDescriptor) pre
}
m.Set(fd, newValue(m, fd, newSeed(n, i), stack))
}
return pref.ValueOfMessage(m)
return protoreflect.ValueOfMessage(m)
}
func panics(f func()) (didPanic bool) {