MM-33945: Update dependencies (#17201)

* MM-33945: Update dependencies

Ran `make update-dependencies`

https://mattermost.atlassian.net/browse/MM-33945

```release-notes
NONE
```

* fix test

vendor/github.com/vmihailenco/msgpack/v5/.travis.yml

@@ -2,8 +2,8 @@ sudo: false
 language: go
 
 go:
-  - 1.14.x
   - 1.15.x
+  - 1.16.x
   - tip
 
 matrix:

vendor/github.com/vmihailenco/msgpack/v5/README.md

@@ -5,7 +5,8 @@
 [![Documentation](https://img.shields.io/badge/msgpack-documentation-informational)](https://msgpack.uptrace.dev/)
 [![Chat](https://discordapp.com/api/guilds/752070105847955518/widget.png)](https://discord.gg/rWtp5Aj)
 
-> :heart: [**Uptrace.dev** - distributed traces, logs, and errors in one place](https://uptrace.dev)
+> :heart:
+> [**Uptrace.dev** - All-in-one tool to optimize performance and monitor errors & logs](https://uptrace.dev/?utm_source=gh-msgpack&utm_campaign=gh-msgpack-var2)
 
 - Join [Discord](https://discord.gg/rWtp5Aj) to ask questions.
 - [Documentation](https://msgpack.uptrace.dev)

vendor/github.com/vmihailenco/msgpack/v5/decode.go

@@ -444,6 +444,7 @@ func (d *Decoder) DecodeInterface() (interface{}, error) {
 //   - int8, int16, and int32 are converted to int64,
 //   - uint8, uint16, and uint32 are converted to uint64,
 //   - float32 is converted to float64.
+//   - []byte is converted to string.
 func (d *Decoder) DecodeInterfaceLoose() (interface{}, error) {
 	c, err := d.readCode()
 	if err != nil {
@@ -478,9 +479,8 @@ func (d *Decoder) DecodeInterfaceLoose() (interface{}, error) {
 		return d.uint(c)
 	case msgpcode.Int8, msgpcode.Int16, msgpcode.Int32, msgpcode.Int64:
 		return d.int(c)
-	case msgpcode.Bin8, msgpcode.Bin16, msgpcode.Bin32:
-		return d.bytes(c, nil)
-	case msgpcode.Str8, msgpcode.Str16, msgpcode.Str32:
+	case msgpcode.Str8, msgpcode.Str16, msgpcode.Str32,
+		msgpcode.Bin8, msgpcode.Bin16, msgpcode.Bin32:
 		return d.string(c)
 	case msgpcode.Array16, msgpcode.Array32:
 		return d.decodeSlice(c)

vendor/github.com/vmihailenco/msgpack/v5/decode_map.go

@@ -1,12 +1,15 @@
 package msgpack
 
 import (
+	"errors"
 	"fmt"
 	"reflect"
 
 	"github.com/vmihailenco/msgpack/v5/msgpcode"
 )
 
+var errArrayStruct = errors.New("msgpack: number of fields in array-encoded struct has changed")
+
 var (
 	mapStringStringPtrType = reflect.TypeOf((*map[string]string)(nil))
 	mapStringStringType    = mapStringStringPtrType.Elem()
@@ -274,43 +277,43 @@ func decodeStructValue(d *Decoder, v reflect.Value) error {
 		return err
 	}
 
-	var isArray bool
-
 	n, err := d.mapLen(c)
-	if err != nil {
-		var err2 error
-		n, err2 = d.arrayLen(c)
-		if err2 != nil {
-			return err
-		}
-		isArray = true
+	if err == nil {
+		return d.decodeStruct(v, n)
 	}
+
+	var err2 error
+	n, err2 = d.arrayLen(c)
+	if err2 != nil {
+		return err
+	}
+
 	if n == -1 {
 		v.Set(reflect.Zero(v.Type()))
 		return nil
 	}
 
 	fields := structs.Fields(v.Type(), d.structTag)
-	if isArray {
-		for i, f := range fields.List {
-			if i >= n {
-				break
-			}
-			if err := f.DecodeValue(d, v); err != nil {
-				return err
-			}
-		}
+	if n != len(fields.List) {
+		return errArrayStruct
+	}
 
-		// Skip extra values.
-		for i := len(fields.List); i < n; i++ {
-			if err := d.Skip(); err != nil {
-				return err
-			}
+	for _, f := range fields.List {
+		if err := f.DecodeValue(d, v); err != nil {
+			return err
 		}
+	}
 
+	return nil
+}
+
+func (d *Decoder) decodeStruct(v reflect.Value, n int) error {
+	if n == -1 {
+		v.Set(reflect.Zero(v.Type()))
 		return nil
 	}
 
+	fields := structs.Fields(v.Type(), d.structTag)
 	for i := 0; i < n; i++ {
 		name, err := d.decodeStringTemp()
 		if err != nil {
@@ -321,9 +324,13 @@ func decodeStructValue(d *Decoder, v reflect.Value) error {
 			if err := f.DecodeValue(d, v); err != nil {
 				return err
 			}
-		} else if d.flags&disallowUnknownFieldsFlag != 0 {
+			continue
+		}
+
+		if d.flags&disallowUnknownFieldsFlag != 0 {
 			return fmt.Errorf("msgpack: unknown field %q", name)
-		} else if err := d.Skip(); err != nil {
+		}
+		if err := d.Skip(); err != nil {
 			return err
 		}
 	}

vendor/github.com/vmihailenco/msgpack/v5/decode_value.go

@@ -59,43 +59,43 @@ func _getDecoder(typ reflect.Type) decoderFunc {
 
 	if kind == reflect.Ptr {
 		if _, ok := typeDecMap.Load(typ.Elem()); ok {
-			return ptrDecoderFunc(typ)
+			return ptrValueDecoder(typ)
 		}
 	}
 
 	if typ.Implements(customDecoderType) {
-		return decodeCustomValue
+		return nilAwareDecoder(typ, decodeCustomValue)
 	}
 	if typ.Implements(unmarshalerType) {
-		return unmarshalValue
+		return nilAwareDecoder(typ, unmarshalValue)
 	}
 	if typ.Implements(binaryUnmarshalerType) {
-		return unmarshalBinaryValue
+		return nilAwareDecoder(typ, unmarshalBinaryValue)
 	}
 	if typ.Implements(textUnmarshalerType) {
-		return unmarshalTextValue
+		return nilAwareDecoder(typ, unmarshalTextValue)
 	}
 
 	// Addressable struct field value.
 	if kind != reflect.Ptr {
 		ptr := reflect.PtrTo(typ)
 		if ptr.Implements(customDecoderType) {
-			return decodeCustomValueAddr
+			return addrDecoder(nilAwareDecoder(typ, decodeCustomValue))
 		}
 		if ptr.Implements(unmarshalerType) {
-			return unmarshalValueAddr
+			return addrDecoder(nilAwareDecoder(typ, unmarshalValue))
 		}
 		if ptr.Implements(binaryUnmarshalerType) {
-			return unmarshalBinaryValueAddr
+			return addrDecoder(nilAwareDecoder(typ, unmarshalBinaryValue))
 		}
 		if ptr.Implements(textUnmarshalerType) {
-			return unmarshalTextValueAddr
+			return addrDecoder(nilAwareDecoder(typ, unmarshalTextValue))
 		}
 	}
 
 	switch kind {
 	case reflect.Ptr:
-		return ptrDecoderFunc(typ)
+		return ptrValueDecoder(typ)
 	case reflect.Slice:
 		elem := typ.Elem()
 		if elem.Kind() == reflect.Uint8 {
@@ -122,7 +122,7 @@ func _getDecoder(typ reflect.Type) decoderFunc {
 	return valueDecoders[kind]
 }
 
-func ptrDecoderFunc(typ reflect.Type) decoderFunc {
+func ptrValueDecoder(typ reflect.Type) decoderFunc {
 	decoder := getDecoder(typ.Elem())
 	return func(d *Decoder, v reflect.Value) error {
 		if d.hasNilCode() {
@@ -138,53 +138,34 @@ func ptrDecoderFunc(typ reflect.Type) decoderFunc {
 	}
 }
 
-func decodeCustomValueAddr(d *Decoder, v reflect.Value) error {
-	if !v.CanAddr() {
-		return fmt.Errorf("msgpack: Decode(nonaddressable %T)", v.Interface())
+func addrDecoder(fn decoderFunc) decoderFunc {
+	return func(d *Decoder, v reflect.Value) error {
+		if !v.CanAddr() {
+			return fmt.Errorf("msgpack: Decode(nonaddressable %T)", v.Interface())
+		}
+		return fn(d, v.Addr())
 	}
-	return decodeCustomValue(d, v.Addr())
 }
 
-func decodeCustomValue(d *Decoder, v reflect.Value) error {
-	if d.hasNilCode() {
-		return d.decodeNilValue(v)
+func nilAwareDecoder(typ reflect.Type, fn decoderFunc) decoderFunc {
+	if nilable(typ.Kind()) {
+		return func(d *Decoder, v reflect.Value) error {
+			if d.hasNilCode() {
+				return d.decodeNilValue(v)
+			}
+			if v.IsNil() {
+				v.Set(reflect.New(v.Type().Elem()))
+			}
+			return fn(d, v)
+		}
 	}
 
-	if v.IsNil() {
-		v.Set(reflect.New(v.Type().Elem()))
+	return func(d *Decoder, v reflect.Value) error {
+		if d.hasNilCode() {
+			return d.decodeNilValue(v)
+		}
+		return fn(d, v)
 	}
-
-	decoder := v.Interface().(CustomDecoder)
-	return decoder.DecodeMsgpack(d)
-}
-
-func unmarshalValueAddr(d *Decoder, v reflect.Value) error {
-	if !v.CanAddr() {
-		return fmt.Errorf("msgpack: Decode(nonaddressable %T)", v.Interface())
-	}
-	return unmarshalValue(d, v.Addr())
-}
-
-func unmarshalValue(d *Decoder, v reflect.Value) error {
-	if d.hasNilCode() {
-		return d.decodeNilValue(v)
-	}
-
-	if v.IsNil() {
-		v.Set(reflect.New(v.Type().Elem()))
-	}
-
-	var b []byte
-
-	d.rec = make([]byte, 0, 64)
-	if err := d.Skip(); err != nil {
-		return err
-	}
-	b = d.rec
-	d.rec = nil
-
-	unmarshaler := v.Interface().(Unmarshaler)
-	return unmarshaler.UnmarshalMsgpack(b)
 }
 
 func decodeBoolValue(d *Decoder, v reflect.Value) error {
@@ -229,22 +210,26 @@ func decodeUnsupportedValue(d *Decoder, v reflect.Value) error {
 
 //------------------------------------------------------------------------------
 
-func unmarshalBinaryValueAddr(d *Decoder, v reflect.Value) error {
-	if !v.CanAddr() {
-		return fmt.Errorf("msgpack: Decode(nonaddressable %T)", v.Interface())
+func decodeCustomValue(d *Decoder, v reflect.Value) error {
+	decoder := v.Interface().(CustomDecoder)
+	return decoder.DecodeMsgpack(d)
+}
+
+func unmarshalValue(d *Decoder, v reflect.Value) error {
+	var b []byte
+
+	d.rec = make([]byte, 0, 64)
+	if err := d.Skip(); err != nil {
+		return err
 	}
-	return unmarshalBinaryValue(d, v.Addr())
+	b = d.rec
+	d.rec = nil
+
+	unmarshaler := v.Interface().(Unmarshaler)
+	return unmarshaler.UnmarshalMsgpack(b)
 }
 
 func unmarshalBinaryValue(d *Decoder, v reflect.Value) error {
-	if d.hasNilCode() {
-		return d.decodeNilValue(v)
-	}
-
-	if v.IsNil() {
-		v.Set(reflect.New(v.Type().Elem()))
-	}
-
 	data, err := d.DecodeBytes()
 	if err != nil {
 		return err
@@ -254,24 +239,7 @@ func unmarshalBinaryValue(d *Decoder, v reflect.Value) error {
 	return unmarshaler.UnmarshalBinary(data)
 }
 
-//------------------------------------------------------------------------------
-
-func unmarshalTextValueAddr(d *Decoder, v reflect.Value) error {
-	if !v.CanAddr() {
-		return fmt.Errorf("msgpack: Decode(nonaddressable %T)", v.Interface())
-	}
-	return unmarshalTextValue(d, v.Addr())
-}
-
 func unmarshalTextValue(d *Decoder, v reflect.Value) error {
-	if d.hasNilCode() {
-		return d.decodeNilValue(v)
-	}
-
-	if v.IsNil() {
-		v.Set(reflect.New(v.Type().Elem()))
-	}
-
 	data, err := d.DecodeBytes()
 	if err != nil {
 		return err

vendor/github.com/vmihailenco/msgpack/v5/encode_value.go

@@ -139,7 +139,7 @@ func encodeCustomValuePtr(e *Encoder, v reflect.Value) error {
 }
 
 func encodeCustomValue(e *Encoder, v reflect.Value) error {
-	if nilable(v) && v.IsNil() {
+	if nilable(v.Kind()) && v.IsNil() {
 		return e.EncodeNil()
 	}
 
@@ -155,7 +155,7 @@ func marshalValuePtr(e *Encoder, v reflect.Value) error {
 }
 
 func marshalValue(e *Encoder, v reflect.Value) error {
-	if nilable(v) && v.IsNil() {
+	if nilable(v.Kind()) && v.IsNil() {
 		return e.EncodeNil()
 	}
 
@@ -190,8 +190,8 @@ func encodeUnsupportedValue(e *Encoder, v reflect.Value) error {
 	return fmt.Errorf("msgpack: Encode(unsupported %s)", v.Type())
 }
 
-func nilable(v reflect.Value) bool {
-	switch v.Kind() {
+func nilable(kind reflect.Kind) bool {
+	switch kind {
 	case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice:
 		return true
 	}
@@ -208,7 +208,7 @@ func marshalBinaryValueAddr(e *Encoder, v reflect.Value) error {
 }
 
 func marshalBinaryValue(e *Encoder, v reflect.Value) error {
-	if nilable(v) && v.IsNil() {
+	if nilable(v.Kind()) && v.IsNil() {
 		return e.EncodeNil()
 	}
 
@@ -231,7 +231,7 @@ func marshalTextValueAddr(e *Encoder, v reflect.Value) error {
 }
 
 func marshalTextValue(e *Encoder, v reflect.Value) error {
-	if nilable(v) && v.IsNil() {
+	if nilable(v.Kind()) && v.IsNil() {
 		return e.EncodeNil()
 	}
 

vendor/github.com/vmihailenco/msgpack/v5/ext.go

@@ -142,18 +142,7 @@ func makeExtDecoder(
 	typ reflect.Type,
 	decoder func(d *Decoder, v reflect.Value, extLen int) error,
 ) decoderFunc {
-	nilable := typ.Kind() == reflect.Ptr
-
-	return func(d *Decoder, v reflect.Value) error {
-		if d.hasNilCode() {
-			v.Set(reflect.Zero(typ))
-			return d.DecodeNil()
-		}
-
-		if nilable && v.IsNil() {
-			v.Set(reflect.New(typ.Elem()))
-		}
-
+	return nilAwareDecoder(typ, func(d *Decoder, v reflect.Value) error {
 		extID, extLen, err := d.DecodeExtHeader()
 		if err != nil {
 			return err
@@ -162,7 +151,7 @@ func makeExtDecoder(
 			return fmt.Errorf("msgpack: got ext type=%d, wanted %d", extID, wantedExtID)
 		}
 		return decoder(d, v, extLen)
-	}
+	})
 }
 
 func makeExtDecoderAddr(extDecoder decoderFunc) decoderFunc {
@@ -266,7 +255,7 @@ func (d *Decoder) decodeInterfaceExt(c byte) (interface{}, error) {
 	}
 
 	v := reflect.New(info.Type).Elem()
-	if nilable(v) && v.IsNil() {
+	if nilable(v.Kind()) && v.IsNil() {
 		v.Set(reflect.New(info.Type.Elem()))
 	}
 

vendor/github.com/vmihailenco/msgpack/v5/go.mod

@@ -1,8 +1,8 @@
 module github.com/vmihailenco/msgpack/v5
 
+go 1.11
+
 require (
 	github.com/stretchr/testify v1.6.1
 	github.com/vmihailenco/tagparser/v2 v2.0.0
 )
-
-go 1.11

vendor/github.com/vmihailenco/msgpack/v5/types.go

@@ -313,7 +313,14 @@ func shouldInline(fs *fields, typ reflect.Type, f *field, tag string) bool {
 	return true
 }
 
+type isZeroer interface {
+	IsZero() bool
+}
+
 func isEmptyValue(v reflect.Value) bool {
+	if z, ok := v.Interface().(isZeroer); ok {
+		return z.IsZero()
+	}
 	switch v.Kind() {
 	case reflect.Array, reflect.Map, reflect.Slice, reflect.String:
 		return v.Len() == 0