[VOL-5374] go version upgrade to 1.23.1 and few other package versions upgrade
Signed-off-by: akashreddyk <akash.kankanala@radisys.com>
Change-Id: I50531e8febdc00b335ebbe5a4b1099fc3bf6d5b4
diff --git a/vendor/google.golang.org/protobuf/encoding/protojson/decode.go b/vendor/google.golang.org/protobuf/encoding/protojson/decode.go
index 07da5db..737d687 100644
--- a/vendor/google.golang.org/protobuf/encoding/protojson/decode.go
+++ b/vendor/google.golang.org/protobuf/encoding/protojson/decode.go
@@ -11,6 +11,7 @@
"strconv"
"strings"
+ "google.golang.org/protobuf/encoding/protowire"
"google.golang.org/protobuf/internal/encoding/json"
"google.golang.org/protobuf/internal/encoding/messageset"
"google.golang.org/protobuf/internal/errors"
@@ -19,11 +20,11 @@
"google.golang.org/protobuf/internal/pragma"
"google.golang.org/protobuf/internal/set"
"google.golang.org/protobuf/proto"
- pref "google.golang.org/protobuf/reflect/protoreflect"
+ "google.golang.org/protobuf/reflect/protoreflect"
"google.golang.org/protobuf/reflect/protoregistry"
)
-// Unmarshal reads the given []byte into the given proto.Message.
+// Unmarshal reads the given []byte into the given [proto.Message].
// The provided message must be mutable (e.g., a non-nil pointer to a message).
func Unmarshal(b []byte, m proto.Message) error {
return UnmarshalOptions{}.Unmarshal(b, m)
@@ -37,7 +38,7 @@
// required fields will not return an error.
AllowPartial bool
- // If DiscardUnknown is set, unknown fields are ignored.
+ // If DiscardUnknown is set, unknown fields and enum name values are ignored.
DiscardUnknown bool
// Resolver is used for looking up types when unmarshaling
@@ -47,9 +48,13 @@
protoregistry.MessageTypeResolver
protoregistry.ExtensionTypeResolver
}
+
+ // RecursionLimit limits how deeply messages may be nested.
+ // If zero, a default limit is applied.
+ RecursionLimit int
}
-// Unmarshal reads the given []byte and populates the given proto.Message
+// Unmarshal reads the given []byte and populates the given [proto.Message]
// using options in the UnmarshalOptions object.
// It will clear the message first before setting the fields.
// If it returns an error, the given message may be partially set.
@@ -67,6 +72,9 @@
if o.Resolver == nil {
o.Resolver = protoregistry.GlobalTypes
}
+ if o.RecursionLimit == 0 {
+ o.RecursionLimit = protowire.DefaultRecursionLimit
+ }
dec := decoder{json.NewDecoder(b), o}
if err := dec.unmarshalMessage(m.ProtoReflect(), false); err != nil {
@@ -94,7 +102,7 @@
}
// newError returns an error object with position info.
-func (d decoder) newError(pos int, f string, x ...interface{}) error {
+func (d decoder) newError(pos int, f string, x ...any) error {
line, column := d.Position(pos)
head := fmt.Sprintf("(line %d:%d): ", line, column)
return errors.New(head+f, x...)
@@ -106,14 +114,18 @@
}
// syntaxError returns a syntax error for given position.
-func (d decoder) syntaxError(pos int, f string, x ...interface{}) error {
+func (d decoder) syntaxError(pos int, f string, x ...any) error {
line, column := d.Position(pos)
head := fmt.Sprintf("syntax error (line %d:%d): ", line, column)
return errors.New(head+f, x...)
}
// unmarshalMessage unmarshals a message into the given protoreflect.Message.
-func (d decoder) unmarshalMessage(m pref.Message, skipTypeURL bool) error {
+func (d decoder) unmarshalMessage(m protoreflect.Message, skipTypeURL bool) error {
+ d.opts.RecursionLimit--
+ if d.opts.RecursionLimit < 0 {
+ return errors.New("exceeded max recursion depth")
+ }
if unmarshal := wellKnownTypeUnmarshaler(m.Descriptor().FullName()); unmarshal != nil {
return unmarshal(d, m)
}
@@ -159,10 +171,10 @@
}
// Get the FieldDescriptor.
- var fd pref.FieldDescriptor
+ var fd protoreflect.FieldDescriptor
if strings.HasPrefix(name, "[") && strings.HasSuffix(name, "]") {
// Only extension names are in [name] format.
- extName := pref.FullName(name[1 : len(name)-1])
+ extName := protoreflect.FullName(name[1 : len(name)-1])
extType, err := d.opts.Resolver.FindExtensionByName(extName)
if err != nil && err != protoregistry.NotFound {
return d.newError(tok.Pos(), "unable to resolve %s: %v", tok.RawString(), err)
@@ -180,11 +192,6 @@
fd = fieldDescs.ByTextName(name)
}
}
- if flags.ProtoLegacy {
- if fd != nil && fd.IsWeak() && fd.Message().IsPlaceholder() {
- fd = nil // reset since the weak reference is not linked in
- }
- }
if fd == nil {
// Field is unknown.
@@ -240,23 +247,23 @@
}
}
-func isKnownValue(fd pref.FieldDescriptor) bool {
+func isKnownValue(fd protoreflect.FieldDescriptor) bool {
md := fd.Message()
return md != nil && md.FullName() == genid.Value_message_fullname
}
-func isNullValue(fd pref.FieldDescriptor) bool {
+func isNullValue(fd protoreflect.FieldDescriptor) bool {
ed := fd.Enum()
return ed != nil && ed.FullName() == genid.NullValue_enum_fullname
}
// unmarshalSingular unmarshals to the non-repeated field specified
// by the given FieldDescriptor.
-func (d decoder) unmarshalSingular(m pref.Message, fd pref.FieldDescriptor) error {
- var val pref.Value
+func (d decoder) unmarshalSingular(m protoreflect.Message, fd protoreflect.FieldDescriptor) error {
+ var val protoreflect.Value
var err error
switch fd.Kind() {
- case pref.MessageKind, pref.GroupKind:
+ case protoreflect.MessageKind, protoreflect.GroupKind:
val = m.NewField(fd)
err = d.unmarshalMessage(val.Message(), false)
default:
@@ -266,70 +273,72 @@
if err != nil {
return err
}
- m.Set(fd, val)
+ if val.IsValid() {
+ m.Set(fd, val)
+ }
return nil
}
// unmarshalScalar unmarshals to a scalar/enum protoreflect.Value specified by
// the given FieldDescriptor.
-func (d decoder) unmarshalScalar(fd pref.FieldDescriptor) (pref.Value, error) {
+func (d decoder) unmarshalScalar(fd protoreflect.FieldDescriptor) (protoreflect.Value, error) {
const b32 int = 32
const b64 int = 64
tok, err := d.Read()
if err != nil {
- return pref.Value{}, err
+ return protoreflect.Value{}, err
}
kind := fd.Kind()
switch kind {
- case pref.BoolKind:
+ case protoreflect.BoolKind:
if tok.Kind() == json.Bool {
- return pref.ValueOfBool(tok.Bool()), nil
+ return protoreflect.ValueOfBool(tok.Bool()), nil
}
- case pref.Int32Kind, pref.Sint32Kind, pref.Sfixed32Kind:
+ case protoreflect.Int32Kind, protoreflect.Sint32Kind, protoreflect.Sfixed32Kind:
if v, ok := unmarshalInt(tok, b32); ok {
return v, nil
}
- case pref.Int64Kind, pref.Sint64Kind, pref.Sfixed64Kind:
+ case protoreflect.Int64Kind, protoreflect.Sint64Kind, protoreflect.Sfixed64Kind:
if v, ok := unmarshalInt(tok, b64); ok {
return v, nil
}
- case pref.Uint32Kind, pref.Fixed32Kind:
+ case protoreflect.Uint32Kind, protoreflect.Fixed32Kind:
if v, ok := unmarshalUint(tok, b32); ok {
return v, nil
}
- case pref.Uint64Kind, pref.Fixed64Kind:
+ case protoreflect.Uint64Kind, protoreflect.Fixed64Kind:
if v, ok := unmarshalUint(tok, b64); ok {
return v, nil
}
- case pref.FloatKind:
+ case protoreflect.FloatKind:
if v, ok := unmarshalFloat(tok, b32); ok {
return v, nil
}
- case pref.DoubleKind:
+ case protoreflect.DoubleKind:
if v, ok := unmarshalFloat(tok, b64); ok {
return v, nil
}
- case pref.StringKind:
+ case protoreflect.StringKind:
if tok.Kind() == json.String {
- return pref.ValueOfString(tok.ParsedString()), nil
+ return protoreflect.ValueOfString(tok.ParsedString()), nil
}
- case pref.BytesKind:
+ case protoreflect.BytesKind:
if v, ok := unmarshalBytes(tok); ok {
return v, nil
}
- case pref.EnumKind:
- if v, ok := unmarshalEnum(tok, fd); ok {
+ case protoreflect.EnumKind:
+ if v, ok := unmarshalEnum(tok, fd, d.opts.DiscardUnknown); ok {
return v, nil
}
@@ -337,10 +346,10 @@
panic(fmt.Sprintf("unmarshalScalar: invalid scalar kind %v", kind))
}
- return pref.Value{}, d.newError(tok.Pos(), "invalid value for %v type: %v", kind, tok.RawString())
+ return protoreflect.Value{}, d.newError(tok.Pos(), "invalid value for %v field %v: %v", kind, fd.JSONName(), tok.RawString())
}
-func unmarshalInt(tok json.Token, bitSize int) (pref.Value, bool) {
+func unmarshalInt(tok json.Token, bitSize int) (protoreflect.Value, bool) {
switch tok.Kind() {
case json.Number:
return getInt(tok, bitSize)
@@ -349,30 +358,30 @@
// Decode number from string.
s := strings.TrimSpace(tok.ParsedString())
if len(s) != len(tok.ParsedString()) {
- return pref.Value{}, false
+ return protoreflect.Value{}, false
}
dec := json.NewDecoder([]byte(s))
tok, err := dec.Read()
if err != nil {
- return pref.Value{}, false
+ return protoreflect.Value{}, false
}
return getInt(tok, bitSize)
}
- return pref.Value{}, false
+ return protoreflect.Value{}, false
}
-func getInt(tok json.Token, bitSize int) (pref.Value, bool) {
+func getInt(tok json.Token, bitSize int) (protoreflect.Value, bool) {
n, ok := tok.Int(bitSize)
if !ok {
- return pref.Value{}, false
+ return protoreflect.Value{}, false
}
if bitSize == 32 {
- return pref.ValueOfInt32(int32(n)), true
+ return protoreflect.ValueOfInt32(int32(n)), true
}
- return pref.ValueOfInt64(n), true
+ return protoreflect.ValueOfInt64(n), true
}
-func unmarshalUint(tok json.Token, bitSize int) (pref.Value, bool) {
+func unmarshalUint(tok json.Token, bitSize int) (protoreflect.Value, bool) {
switch tok.Kind() {
case json.Number:
return getUint(tok, bitSize)
@@ -381,30 +390,30 @@
// Decode number from string.
s := strings.TrimSpace(tok.ParsedString())
if len(s) != len(tok.ParsedString()) {
- return pref.Value{}, false
+ return protoreflect.Value{}, false
}
dec := json.NewDecoder([]byte(s))
tok, err := dec.Read()
if err != nil {
- return pref.Value{}, false
+ return protoreflect.Value{}, false
}
return getUint(tok, bitSize)
}
- return pref.Value{}, false
+ return protoreflect.Value{}, false
}
-func getUint(tok json.Token, bitSize int) (pref.Value, bool) {
+func getUint(tok json.Token, bitSize int) (protoreflect.Value, bool) {
n, ok := tok.Uint(bitSize)
if !ok {
- return pref.Value{}, false
+ return protoreflect.Value{}, false
}
if bitSize == 32 {
- return pref.ValueOfUint32(uint32(n)), true
+ return protoreflect.ValueOfUint32(uint32(n)), true
}
- return pref.ValueOfUint64(n), true
+ return protoreflect.ValueOfUint64(n), true
}
-func unmarshalFloat(tok json.Token, bitSize int) (pref.Value, bool) {
+func unmarshalFloat(tok json.Token, bitSize int) (protoreflect.Value, bool) {
switch tok.Kind() {
case json.Number:
return getFloat(tok, bitSize)
@@ -414,49 +423,49 @@
switch s {
case "NaN":
if bitSize == 32 {
- return pref.ValueOfFloat32(float32(math.NaN())), true
+ return protoreflect.ValueOfFloat32(float32(math.NaN())), true
}
- return pref.ValueOfFloat64(math.NaN()), true
+ return protoreflect.ValueOfFloat64(math.NaN()), true
case "Infinity":
if bitSize == 32 {
- return pref.ValueOfFloat32(float32(math.Inf(+1))), true
+ return protoreflect.ValueOfFloat32(float32(math.Inf(+1))), true
}
- return pref.ValueOfFloat64(math.Inf(+1)), true
+ return protoreflect.ValueOfFloat64(math.Inf(+1)), true
case "-Infinity":
if bitSize == 32 {
- return pref.ValueOfFloat32(float32(math.Inf(-1))), true
+ return protoreflect.ValueOfFloat32(float32(math.Inf(-1))), true
}
- return pref.ValueOfFloat64(math.Inf(-1)), true
+ return protoreflect.ValueOfFloat64(math.Inf(-1)), true
}
// Decode number from string.
if len(s) != len(strings.TrimSpace(s)) {
- return pref.Value{}, false
+ return protoreflect.Value{}, false
}
dec := json.NewDecoder([]byte(s))
tok, err := dec.Read()
if err != nil {
- return pref.Value{}, false
+ return protoreflect.Value{}, false
}
return getFloat(tok, bitSize)
}
- return pref.Value{}, false
+ return protoreflect.Value{}, false
}
-func getFloat(tok json.Token, bitSize int) (pref.Value, bool) {
+func getFloat(tok json.Token, bitSize int) (protoreflect.Value, bool) {
n, ok := tok.Float(bitSize)
if !ok {
- return pref.Value{}, false
+ return protoreflect.Value{}, false
}
if bitSize == 32 {
- return pref.ValueOfFloat32(float32(n)), true
+ return protoreflect.ValueOfFloat32(float32(n)), true
}
- return pref.ValueOfFloat64(n), true
+ return protoreflect.ValueOfFloat64(n), true
}
-func unmarshalBytes(tok json.Token) (pref.Value, bool) {
+func unmarshalBytes(tok json.Token) (protoreflect.Value, bool) {
if tok.Kind() != json.String {
- return pref.Value{}, false
+ return protoreflect.Value{}, false
}
s := tok.ParsedString()
@@ -469,36 +478,39 @@
}
b, err := enc.DecodeString(s)
if err != nil {
- return pref.Value{}, false
+ return protoreflect.Value{}, false
}
- return pref.ValueOfBytes(b), true
+ return protoreflect.ValueOfBytes(b), true
}
-func unmarshalEnum(tok json.Token, fd pref.FieldDescriptor) (pref.Value, bool) {
+func unmarshalEnum(tok json.Token, fd protoreflect.FieldDescriptor, discardUnknown bool) (protoreflect.Value, bool) {
switch tok.Kind() {
case json.String:
// Lookup EnumNumber based on name.
s := tok.ParsedString()
- if enumVal := fd.Enum().Values().ByName(pref.Name(s)); enumVal != nil {
- return pref.ValueOfEnum(enumVal.Number()), true
+ if enumVal := fd.Enum().Values().ByName(protoreflect.Name(s)); enumVal != nil {
+ return protoreflect.ValueOfEnum(enumVal.Number()), true
+ }
+ if discardUnknown {
+ return protoreflect.Value{}, true
}
case json.Number:
if n, ok := tok.Int(32); ok {
- return pref.ValueOfEnum(pref.EnumNumber(n)), true
+ return protoreflect.ValueOfEnum(protoreflect.EnumNumber(n)), true
}
case json.Null:
// This is only valid for google.protobuf.NullValue.
if isNullValue(fd) {
- return pref.ValueOfEnum(0), true
+ return protoreflect.ValueOfEnum(0), true
}
}
- return pref.Value{}, false
+ return protoreflect.Value{}, false
}
-func (d decoder) unmarshalList(list pref.List, fd pref.FieldDescriptor) error {
+func (d decoder) unmarshalList(list protoreflect.List, fd protoreflect.FieldDescriptor) error {
tok, err := d.Read()
if err != nil {
return err
@@ -508,7 +520,7 @@
}
switch fd.Kind() {
- case pref.MessageKind, pref.GroupKind:
+ case protoreflect.MessageKind, protoreflect.GroupKind:
for {
tok, err := d.Peek()
if err != nil {
@@ -542,14 +554,16 @@
if err != nil {
return err
}
- list.Append(val)
+ if val.IsValid() {
+ list.Append(val)
+ }
}
}
return nil
}
-func (d decoder) unmarshalMap(mmap pref.Map, fd pref.FieldDescriptor) error {
+func (d decoder) unmarshalMap(mmap protoreflect.Map, fd protoreflect.FieldDescriptor) error {
tok, err := d.Read()
if err != nil {
return err
@@ -561,18 +575,18 @@
// Determine ahead whether map entry is a scalar type or a message type in
// order to call the appropriate unmarshalMapValue func inside the for loop
// below.
- var unmarshalMapValue func() (pref.Value, error)
+ var unmarshalMapValue func() (protoreflect.Value, error)
switch fd.MapValue().Kind() {
- case pref.MessageKind, pref.GroupKind:
- unmarshalMapValue = func() (pref.Value, error) {
+ case protoreflect.MessageKind, protoreflect.GroupKind:
+ unmarshalMapValue = func() (protoreflect.Value, error) {
val := mmap.NewValue()
if err := d.unmarshalMessage(val.Message(), false); err != nil {
- return pref.Value{}, err
+ return protoreflect.Value{}, err
}
return val, nil
}
default:
- unmarshalMapValue = func() (pref.Value, error) {
+ unmarshalMapValue = func() (protoreflect.Value, error) {
return d.unmarshalScalar(fd.MapValue())
}
}
@@ -609,8 +623,9 @@
if err != nil {
return err
}
-
- mmap.Set(pkey, pval)
+ if pval.IsValid() {
+ mmap.Set(pkey, pval)
+ }
}
return nil
@@ -618,7 +633,7 @@
// unmarshalMapKey converts given token of Name kind into a protoreflect.MapKey.
// A map key type is any integral or string type.
-func (d decoder) unmarshalMapKey(tok json.Token, fd pref.FieldDescriptor) (pref.MapKey, error) {
+func (d decoder) unmarshalMapKey(tok json.Token, fd protoreflect.FieldDescriptor) (protoreflect.MapKey, error) {
const b32 = 32
const b64 = 64
const base10 = 10
@@ -626,40 +641,40 @@
name := tok.Name()
kind := fd.Kind()
switch kind {
- case pref.StringKind:
- return pref.ValueOfString(name).MapKey(), nil
+ case protoreflect.StringKind:
+ return protoreflect.ValueOfString(name).MapKey(), nil
- case pref.BoolKind:
+ case protoreflect.BoolKind:
switch name {
case "true":
- return pref.ValueOfBool(true).MapKey(), nil
+ return protoreflect.ValueOfBool(true).MapKey(), nil
case "false":
- return pref.ValueOfBool(false).MapKey(), nil
+ return protoreflect.ValueOfBool(false).MapKey(), nil
}
- case pref.Int32Kind, pref.Sint32Kind, pref.Sfixed32Kind:
+ case protoreflect.Int32Kind, protoreflect.Sint32Kind, protoreflect.Sfixed32Kind:
if n, err := strconv.ParseInt(name, base10, b32); err == nil {
- return pref.ValueOfInt32(int32(n)).MapKey(), nil
+ return protoreflect.ValueOfInt32(int32(n)).MapKey(), nil
}
- case pref.Int64Kind, pref.Sint64Kind, pref.Sfixed64Kind:
+ case protoreflect.Int64Kind, protoreflect.Sint64Kind, protoreflect.Sfixed64Kind:
if n, err := strconv.ParseInt(name, base10, b64); err == nil {
- return pref.ValueOfInt64(int64(n)).MapKey(), nil
+ return protoreflect.ValueOfInt64(int64(n)).MapKey(), nil
}
- case pref.Uint32Kind, pref.Fixed32Kind:
+ case protoreflect.Uint32Kind, protoreflect.Fixed32Kind:
if n, err := strconv.ParseUint(name, base10, b32); err == nil {
- return pref.ValueOfUint32(uint32(n)).MapKey(), nil
+ return protoreflect.ValueOfUint32(uint32(n)).MapKey(), nil
}
- case pref.Uint64Kind, pref.Fixed64Kind:
+ case protoreflect.Uint64Kind, protoreflect.Fixed64Kind:
if n, err := strconv.ParseUint(name, base10, b64); err == nil {
- return pref.ValueOfUint64(uint64(n)).MapKey(), nil
+ return protoreflect.ValueOfUint64(uint64(n)).MapKey(), nil
}
default:
panic(fmt.Sprintf("invalid kind for map key: %v", kind))
}
- return pref.MapKey{}, d.newError(tok.Pos(), "invalid value for %v key: %s", kind, tok.RawString())
+ return protoreflect.MapKey{}, d.newError(tok.Pos(), "invalid value for %v key: %s", kind, tok.RawString())
}
diff --git a/vendor/google.golang.org/protobuf/encoding/protojson/doc.go b/vendor/google.golang.org/protobuf/encoding/protojson/doc.go
index 00ea2fe..ae71007 100644
--- a/vendor/google.golang.org/protobuf/encoding/protojson/doc.go
+++ b/vendor/google.golang.org/protobuf/encoding/protojson/doc.go
@@ -4,8 +4,8 @@
// Package protojson marshals and unmarshals protocol buffer messages as JSON
// format. It follows the guide at
-// https://developers.google.com/protocol-buffers/docs/proto3#json.
+// https://protobuf.dev/programming-guides/proto3#json.
//
-// This package produces a different output than the standard "encoding/json"
+// This package produces a different output than the standard [encoding/json]
// package, which does not operate correctly on protocol buffer messages.
package protojson
diff --git a/vendor/google.golang.org/protobuf/encoding/protojson/encode.go b/vendor/google.golang.org/protobuf/encoding/protojson/encode.go
index ba971f0..0e72d85 100644
--- a/vendor/google.golang.org/protobuf/encoding/protojson/encode.go
+++ b/vendor/google.golang.org/protobuf/encoding/protojson/encode.go
@@ -18,7 +18,6 @@
"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"
)
@@ -26,15 +25,17 @@
// Format formats the message as a multiline string.
// This function is only intended for human consumption and ignores errors.
-// Do not depend on the output being stable. It may change over time across
-// different versions of the program.
+// Do not depend on the output being stable. Its output will change across
+// different builds of your program, even when using the same version of the
+// protobuf module.
func Format(m proto.Message) string {
return MarshalOptions{Multiline: true}.Format(m)
}
-// Marshal writes the given proto.Message in JSON format using default options.
-// Do not depend on the output being stable. It may change over time across
-// different versions of the program.
+// Marshal writes the given [proto.Message] in JSON format using default options.
+// Do not depend on the output being stable. Its output will change across
+// different builds of your program, even when using the same version of the
+// protobuf module.
func Marshal(m proto.Message) ([]byte, error) {
return MarshalOptions{}.Marshal(m)
}
@@ -82,6 +83,25 @@
// ╚═══════╧════════════════════════════╝
EmitUnpopulated bool
+ // EmitDefaultValues specifies whether to emit default-valued primitive fields,
+ // empty lists, and empty maps. The fields affected are as follows:
+ // ╔═══════╤════════════════════════════════════════╗
+ // ║ JSON │ Protobuf field ║
+ // ╠═══════╪════════════════════════════════════════╣
+ // ║ false │ non-optional scalar boolean fields ║
+ // ║ 0 │ non-optional scalar numeric fields ║
+ // ║ "" │ non-optional scalar string/byte fields ║
+ // ║ [] │ empty repeated fields ║
+ // ║ {} │ empty map fields ║
+ // ╚═══════╧════════════════════════════════════════╝
+ //
+ // Behaves similarly to EmitUnpopulated, but does not emit "null"-value fields,
+ // i.e. presence-sensing fields that are omitted will remain omitted to preserve
+ // presence-sensing.
+ // EmitUnpopulated takes precedence over EmitDefaultValues since the former generates
+ // a strict superset of the latter.
+ EmitDefaultValues bool
+
// Resolver is used for looking up types when expanding google.protobuf.Any
// messages. If nil, this defaults to using protoregistry.GlobalTypes.
Resolver interface {
@@ -92,8 +112,9 @@
// Format formats the message as a string.
// This method is only intended for human consumption and ignores errors.
-// Do not depend on the output being stable. It may change over time across
-// different versions of the program.
+// Do not depend on the output being stable. Its output will change across
+// different builds of your program, even when using the same version of the
+// protobuf module.
func (o MarshalOptions) Format(m proto.Message) string {
if m == nil || !m.ProtoReflect().IsValid() {
return "<nil>" // invalid syntax, but okay since this is for debugging
@@ -103,17 +124,24 @@
return string(b)
}
-// Marshal marshals the given proto.Message in the JSON format using options in
-// MarshalOptions. Do not depend on the output being stable. It may change over
-// time across different versions of the program.
+// Marshal marshals the given [proto.Message] in the JSON format using options in
+// Do not depend on the output being stable. Its output will change across
+// different builds of your program, even when using the same version of the
+// protobuf module.
func (o MarshalOptions) Marshal(m proto.Message) ([]byte, error) {
- return o.marshal(m)
+ return o.marshal(nil, m)
+}
+
+// MarshalAppend appends the JSON format encoding of m to b,
+// returning the result.
+func (o MarshalOptions) MarshalAppend(b []byte, m proto.Message) ([]byte, error) {
+ return o.marshal(b, m)
}
// marshal is a centralized function that all marshal operations go through.
// For profiling purposes, avoid changing the name of this function or
// introducing other code paths for marshal that do not go through this.
-func (o MarshalOptions) marshal(m proto.Message) ([]byte, error) {
+func (o MarshalOptions) marshal(b []byte, m proto.Message) ([]byte, error) {
if o.Multiline && o.Indent == "" {
o.Indent = defaultIndent
}
@@ -121,7 +149,7 @@
o.Resolver = protoregistry.GlobalTypes
}
- internalEnc, err := json.NewEncoder(o.Indent)
+ internalEnc, err := json.NewEncoder(b, o.Indent)
if err != nil {
return nil, err
}
@@ -129,7 +157,7 @@
// Treat nil message interface as an empty message,
// in which case the output in an empty JSON object.
if m == nil {
- return []byte("{}"), nil
+ return append(b, '{', '}'), nil
}
enc := encoder{internalEnc, o}
@@ -164,8 +192,8 @@
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 +201,13 @@
// 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) {
+ skipNull 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 +216,11 @@
}
v := m.Get(fd)
- isProto2Scalar := fd.Syntax() == pref.Proto2 && fd.Default().IsValid()
- isSingularMessage := fd.Cardinality() != pref.Repeated && fd.Message() != nil
- if isProto2Scalar || isSingularMessage {
- v = pref.Value{} // use invalid value to emit null
+ if fd.HasPresence() {
+ if m.skipNull {
+ continue
+ }
+ v = protoreflect.Value{} // use invalid value to emit null
}
if !f(fd, v) {
return
@@ -199,7 +232,7 @@
// 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")
}
@@ -212,15 +245,18 @@
defer e.EndObject()
var fields order.FieldRanger = m
- if e.opts.EmitUnpopulated {
- fields = unpopulatedFieldRanger{m}
+ switch {
+ case e.opts.EmitUnpopulated:
+ fields = unpopulatedFieldRanger{Message: m, skipNull: false}
+ case e.opts.EmitDefaultValues:
+ fields = unpopulatedFieldRanger{Message: m, skipNull: true}
}
if typeURL != "" {
fields = typeURLFieldRanger{fields, typeURL}
}
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 +274,7 @@
}
// 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 +287,44 @@
// 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 +336,7 @@
}
}
- case pref.MessageKind, pref.GroupKind:
+ case protoreflect.MessageKind, protoreflect.GroupKind:
if err := e.marshalMessage(val.Message(), ""); err != nil {
return err
}
@@ -312,7 +348,7 @@
}
// 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 +362,12 @@
}
// 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
}
diff --git a/vendor/google.golang.org/protobuf/encoding/protojson/well_known_types.go b/vendor/google.golang.org/protobuf/encoding/protojson/well_known_types.go
index 72924a9..e9fe103 100644
--- a/vendor/google.golang.org/protobuf/encoding/protojson/well_known_types.go
+++ b/vendor/google.golang.org/protobuf/encoding/protojson/well_known_types.go
@@ -17,14 +17,14 @@
"google.golang.org/protobuf/internal/genid"
"google.golang.org/protobuf/internal/strs"
"google.golang.org/protobuf/proto"
- pref "google.golang.org/protobuf/reflect/protoreflect"
+ "google.golang.org/protobuf/reflect/protoreflect"
)
-type marshalFunc func(encoder, pref.Message) error
+type marshalFunc func(encoder, protoreflect.Message) error
// wellKnownTypeMarshaler returns a marshal function if the message type
// has specialized serialization behavior. It returns nil otherwise.
-func wellKnownTypeMarshaler(name pref.FullName) marshalFunc {
+func wellKnownTypeMarshaler(name protoreflect.FullName) marshalFunc {
if name.Parent() == genid.GoogleProtobuf_package {
switch name.Name() {
case genid.Any_message_name:
@@ -58,11 +58,11 @@
return nil
}
-type unmarshalFunc func(decoder, pref.Message) error
+type unmarshalFunc func(decoder, protoreflect.Message) error
// wellKnownTypeUnmarshaler returns a unmarshal function if the message type
// has specialized serialization behavior. It returns nil otherwise.
-func wellKnownTypeUnmarshaler(name pref.FullName) unmarshalFunc {
+func wellKnownTypeUnmarshaler(name protoreflect.FullName) unmarshalFunc {
if name.Parent() == genid.GoogleProtobuf_package {
switch name.Name() {
case genid.Any_message_name:
@@ -102,7 +102,7 @@
// custom JSON representation, that representation will be embedded adding a
// field `value` which holds the custom JSON in addition to the `@type` field.
-func (e encoder) marshalAny(m pref.Message) error {
+func (e encoder) marshalAny(m protoreflect.Message) error {
fds := m.Descriptor().Fields()
fdType := fds.ByNumber(genid.Any_TypeUrl_field_number)
fdValue := fds.ByNumber(genid.Any_Value_field_number)
@@ -163,7 +163,7 @@
return nil
}
-func (d decoder) unmarshalAny(m pref.Message) error {
+func (d decoder) unmarshalAny(m protoreflect.Message) error {
// Peek to check for json.ObjectOpen to avoid advancing a read.
start, err := d.Peek()
if err != nil {
@@ -176,7 +176,7 @@
// Use another decoder to parse the unread bytes for @type field. This
// avoids advancing a read from current decoder because the current JSON
// object may contain the fields of the embedded type.
- dec := decoder{d.Clone(), UnmarshalOptions{}}
+ dec := decoder{d.Clone(), UnmarshalOptions{RecursionLimit: d.opts.RecursionLimit}}
tok, err := findTypeURL(dec)
switch err {
case errEmptyObject:
@@ -233,8 +233,8 @@
fdType := fds.ByNumber(genid.Any_TypeUrl_field_number)
fdValue := fds.ByNumber(genid.Any_Value_field_number)
- m.Set(fdType, pref.ValueOfString(typeURL))
- m.Set(fdValue, pref.ValueOfBytes(b))
+ m.Set(fdType, protoreflect.ValueOfString(typeURL))
+ m.Set(fdValue, protoreflect.ValueOfBytes(b))
return nil
}
@@ -308,53 +308,34 @@
// array) in order to advance the read to the next JSON value. It relies on
// the decoder returning an error if the types are not in valid sequence.
func (d decoder) skipJSONValue() error {
- tok, err := d.Read()
- if err != nil {
- return err
- }
- // Only need to continue reading for objects and arrays.
- switch tok.Kind() {
- case json.ObjectOpen:
- for {
- tok, err := d.Read()
- if err != nil {
- return err
- }
- switch tok.Kind() {
- case json.ObjectClose:
- return nil
- case json.Name:
- // Skip object field value.
- if err := d.skipJSONValue(); err != nil {
- return err
- }
- }
+ var open int
+ for {
+ tok, err := d.Read()
+ if err != nil {
+ return err
}
-
- case json.ArrayOpen:
- for {
- tok, err := d.Peek()
- if err != nil {
- return err
+ switch tok.Kind() {
+ case json.ObjectClose, json.ArrayClose:
+ open--
+ case json.ObjectOpen, json.ArrayOpen:
+ open++
+ if open > d.opts.RecursionLimit {
+ return errors.New("exceeded max recursion depth")
}
- switch tok.Kind() {
- case json.ArrayClose:
- d.Read()
- return nil
- default:
- // Skip array item.
- if err := d.skipJSONValue(); err != nil {
- return err
- }
- }
+ case json.EOF:
+ // This can only happen if there's a bug in Decoder.Read.
+ // Avoid an infinite loop if this does happen.
+ return errors.New("unexpected EOF")
+ }
+ if open == 0 {
+ return nil
}
}
- return nil
}
// unmarshalAnyValue unmarshals the given custom-type message from the JSON
// object's "value" field.
-func (d decoder) unmarshalAnyValue(unmarshal unmarshalFunc, m pref.Message) error {
+func (d decoder) unmarshalAnyValue(unmarshal unmarshalFunc, m protoreflect.Message) error {
// Skip ObjectOpen, and start reading the fields.
d.Read()
@@ -367,7 +348,11 @@
switch tok.Kind() {
case json.ObjectClose:
if !found {
- return d.newError(tok.Pos(), `missing "value" field`)
+ // We tolerate an omitted `value` field with the google.protobuf.Empty Well-Known-Type,
+ // for compatibility with other proto runtimes that have interpreted the spec differently.
+ if m.Descriptor().FullName() != genid.Empty_message_fullname {
+ return d.newError(tok.Pos(), `missing "value" field`)
+ }
}
return nil
@@ -402,13 +387,13 @@
// Wrapper types are encoded as JSON primitives like string, number or boolean.
-func (e encoder) marshalWrapperType(m pref.Message) error {
+func (e encoder) marshalWrapperType(m protoreflect.Message) error {
fd := m.Descriptor().Fields().ByNumber(genid.WrapperValue_Value_field_number)
val := m.Get(fd)
return e.marshalSingular(val, fd)
}
-func (d decoder) unmarshalWrapperType(m pref.Message) error {
+func (d decoder) unmarshalWrapperType(m protoreflect.Message) error {
fd := m.Descriptor().Fields().ByNumber(genid.WrapperValue_Value_field_number)
val, err := d.unmarshalScalar(fd)
if err != nil {
@@ -420,13 +405,13 @@
// The JSON representation for Empty is an empty JSON object.
-func (e encoder) marshalEmpty(pref.Message) error {
+func (e encoder) marshalEmpty(protoreflect.Message) error {
e.StartObject()
e.EndObject()
return nil
}
-func (d decoder) unmarshalEmpty(pref.Message) error {
+func (d decoder) unmarshalEmpty(protoreflect.Message) error {
tok, err := d.Read()
if err != nil {
return err
@@ -462,12 +447,12 @@
// The JSON representation for Struct is a JSON object that contains the encoded
// Struct.fields map and follows the serialization rules for a map.
-func (e encoder) marshalStruct(m pref.Message) error {
+func (e encoder) marshalStruct(m protoreflect.Message) error {
fd := m.Descriptor().Fields().ByNumber(genid.Struct_Fields_field_number)
return e.marshalMap(m.Get(fd).Map(), fd)
}
-func (d decoder) unmarshalStruct(m pref.Message) error {
+func (d decoder) unmarshalStruct(m protoreflect.Message) error {
fd := m.Descriptor().Fields().ByNumber(genid.Struct_Fields_field_number)
return d.unmarshalMap(m.Mutable(fd).Map(), fd)
}
@@ -476,12 +461,12 @@
// ListValue.values repeated field and follows the serialization rules for a
// repeated field.
-func (e encoder) marshalListValue(m pref.Message) error {
+func (e encoder) marshalListValue(m protoreflect.Message) error {
fd := m.Descriptor().Fields().ByNumber(genid.ListValue_Values_field_number)
return e.marshalList(m.Get(fd).List(), fd)
}
-func (d decoder) unmarshalListValue(m pref.Message) error {
+func (d decoder) unmarshalListValue(m protoreflect.Message) error {
fd := m.Descriptor().Fields().ByNumber(genid.ListValue_Values_field_number)
return d.unmarshalList(m.Mutable(fd).List(), fd)
}
@@ -490,7 +475,7 @@
// set. Each of the field in the oneof has its own custom serialization rule. A
// Value message needs to be a oneof field set, else it is an error.
-func (e encoder) marshalKnownValue(m pref.Message) error {
+func (e encoder) marshalKnownValue(m protoreflect.Message) error {
od := m.Descriptor().Oneofs().ByName(genid.Value_Kind_oneof_name)
fd := m.WhichOneof(od)
if fd == nil {
@@ -504,19 +489,19 @@
return e.marshalSingular(m.Get(fd), fd)
}
-func (d decoder) unmarshalKnownValue(m pref.Message) error {
+func (d decoder) unmarshalKnownValue(m protoreflect.Message) error {
tok, err := d.Peek()
if err != nil {
return err
}
- var fd pref.FieldDescriptor
- var val pref.Value
+ var fd protoreflect.FieldDescriptor
+ var val protoreflect.Value
switch tok.Kind() {
case json.Null:
d.Read()
fd = m.Descriptor().Fields().ByNumber(genid.Value_NullValue_field_number)
- val = pref.ValueOfEnum(0)
+ val = protoreflect.ValueOfEnum(0)
case json.Bool:
tok, err := d.Read()
@@ -524,7 +509,7 @@
return err
}
fd = m.Descriptor().Fields().ByNumber(genid.Value_BoolValue_field_number)
- val = pref.ValueOfBool(tok.Bool())
+ val = protoreflect.ValueOfBool(tok.Bool())
case json.Number:
tok, err := d.Read()
@@ -550,7 +535,7 @@
return err
}
fd = m.Descriptor().Fields().ByNumber(genid.Value_StringValue_field_number)
- val = pref.ValueOfString(tok.ParsedString())
+ val = protoreflect.ValueOfString(tok.ParsedString())
case json.ObjectOpen:
fd = m.Descriptor().Fields().ByNumber(genid.Value_StructValue_field_number)
@@ -591,7 +576,7 @@
maxSecondsInDuration = 315576000000
)
-func (e encoder) marshalDuration(m pref.Message) error {
+func (e encoder) marshalDuration(m protoreflect.Message) error {
fds := m.Descriptor().Fields()
fdSeconds := fds.ByNumber(genid.Duration_Seconds_field_number)
fdNanos := fds.ByNumber(genid.Duration_Nanos_field_number)
@@ -623,7 +608,7 @@
return nil
}
-func (d decoder) unmarshalDuration(m pref.Message) error {
+func (d decoder) unmarshalDuration(m protoreflect.Message) error {
tok, err := d.Read()
if err != nil {
return err
@@ -646,8 +631,8 @@
fdSeconds := fds.ByNumber(genid.Duration_Seconds_field_number)
fdNanos := fds.ByNumber(genid.Duration_Nanos_field_number)
- m.Set(fdSeconds, pref.ValueOfInt64(secs))
- m.Set(fdNanos, pref.ValueOfInt32(nanos))
+ m.Set(fdSeconds, protoreflect.ValueOfInt64(secs))
+ m.Set(fdNanos, protoreflect.ValueOfInt32(nanos))
return nil
}
@@ -779,7 +764,7 @@
minTimestampSeconds = -62135596800
)
-func (e encoder) marshalTimestamp(m pref.Message) error {
+func (e encoder) marshalTimestamp(m protoreflect.Message) error {
fds := m.Descriptor().Fields()
fdSeconds := fds.ByNumber(genid.Timestamp_Seconds_field_number)
fdNanos := fds.ByNumber(genid.Timestamp_Nanos_field_number)
@@ -805,7 +790,7 @@
return nil
}
-func (d decoder) unmarshalTimestamp(m pref.Message) error {
+func (d decoder) unmarshalTimestamp(m protoreflect.Message) error {
tok, err := d.Read()
if err != nil {
return err
@@ -814,23 +799,29 @@
return d.unexpectedTokenError(tok)
}
- t, err := time.Parse(time.RFC3339Nano, tok.ParsedString())
+ s := tok.ParsedString()
+ t, err := time.Parse(time.RFC3339Nano, s)
if err != nil {
return d.newError(tok.Pos(), "invalid %v value %v", genid.Timestamp_message_fullname, tok.RawString())
}
- // Validate seconds. No need to validate nanos because time.Parse would have
- // covered that already.
+ // Validate seconds.
secs := t.Unix()
if secs < minTimestampSeconds || secs > maxTimestampSeconds {
return d.newError(tok.Pos(), "%v value out of range: %v", genid.Timestamp_message_fullname, tok.RawString())
}
+ // Validate subseconds.
+ i := strings.LastIndexByte(s, '.') // start of subsecond field
+ j := strings.LastIndexAny(s, "Z-+") // start of timezone field
+ if i >= 0 && j >= i && j-i > len(".999999999") {
+ return d.newError(tok.Pos(), "invalid %v value %v", genid.Timestamp_message_fullname, tok.RawString())
+ }
fds := m.Descriptor().Fields()
fdSeconds := fds.ByNumber(genid.Timestamp_Seconds_field_number)
fdNanos := fds.ByNumber(genid.Timestamp_Nanos_field_number)
- m.Set(fdSeconds, pref.ValueOfInt64(secs))
- m.Set(fdNanos, pref.ValueOfInt32(int32(t.Nanosecond())))
+ m.Set(fdSeconds, protoreflect.ValueOfInt64(secs))
+ m.Set(fdNanos, protoreflect.ValueOfInt32(int32(t.Nanosecond())))
return nil
}
@@ -839,14 +830,14 @@
// lower-camel naming conventions. Encoding should fail if the path name would
// end up differently after a round-trip.
-func (e encoder) marshalFieldMask(m pref.Message) error {
+func (e encoder) marshalFieldMask(m protoreflect.Message) error {
fd := m.Descriptor().Fields().ByNumber(genid.FieldMask_Paths_field_number)
list := m.Get(fd).List()
paths := make([]string, 0, list.Len())
for i := 0; i < list.Len(); i++ {
s := list.Get(i).String()
- if !pref.FullName(s).IsValid() {
+ if !protoreflect.FullName(s).IsValid() {
return errors.New("%s contains invalid path: %q", genid.FieldMask_Paths_field_fullname, s)
}
// Return error if conversion to camelCase is not reversible.
@@ -861,7 +852,7 @@
return nil
}
-func (d decoder) unmarshalFieldMask(m pref.Message) error {
+func (d decoder) unmarshalFieldMask(m protoreflect.Message) error {
tok, err := d.Read()
if err != nil {
return err
@@ -880,10 +871,10 @@
for _, s0 := range paths {
s := strs.JSONSnakeCase(s0)
- if strings.Contains(s0, "_") || !pref.FullName(s).IsValid() {
+ if strings.Contains(s0, "_") || !protoreflect.FullName(s).IsValid() {
return d.newError(tok.Pos(), "%v contains invalid path: %q", genid.FieldMask_Paths_field_fullname, s0)
}
- list.Append(pref.ValueOfString(s))
+ list.Append(protoreflect.ValueOfString(s))
}
return nil
}