chore: use ogen-go/errors instead of xerrors

any_test.go

@@ -9,7 +9,8 @@ import (
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
-	"golang.org/x/xerrors"
+
+	"github.com/ogen-go/errors"
 )
 
 // NB: Any left intentionally unexported
@@ -93,30 +94,30 @@ func (e *Encoder) Any(a Any) {
 func (v *Any) Read(d *Decoder) error {
 	switch d.Next() {
 	case Invalid:
-		return xerrors.New("invalid")
+		return errors.New("invalid")
 	case Number:
 		n, err := d.Number()
 		if err != nil {
-			return xerrors.Errorf("number: %w", err)
+			return errors.Wrap(err, "number")
 		}
 		v.Number = n
 		v.Type = AnyNumber
 	case String:
 		s, err := d.Str()
 		if err != nil {
-			return xerrors.Errorf("str: %w", err)
+			return errors.Wrap(err, "str")
 		}
 		v.Str = s
 		v.Type = AnyStr
 	case Nil:
 		if err := d.Null(); err != nil {
-			return xerrors.Errorf("null: %w", err)
+			return errors.Wrap(err, "null")
 		}
 		v.Type = AnyNull
 	case Bool:
 		b, err := d.Bool()
 		if err != nil {
-			return xerrors.Errorf("bool: %w", err)
+			return errors.Wrap(err, "bool")
 		}
 		v.Bool = b
 		v.Type = AnyBool
@@ -125,27 +126,27 @@ func (v *Any) Read(d *Decoder) error {
 		if err := d.Obj(func(r *Decoder, s string) error {
 			var elem Any
 			if err := elem.Read(r); err != nil {
-				return xerrors.Errorf("elem: %w", err)
+				return errors.Wrap(err, "elem")
 			}
 			elem.Key = s
 			elem.KeyValid = true
 			v.Child = append(v.Child, elem)
 			return nil
 		}); err != nil {
-			return xerrors.Errorf("obj: %w", err)
+			return errors.Wrap(err, "obj")
 		}
 		return nil
 	case Array:
 		v.Type = AnyArr
 		if err := d.Arr(func(r *Decoder) error {
 			var elem Any
 			if err := elem.Read(r); err != nil {
-				return xerrors.Errorf("elem: %w", err)
+				return errors.Wrap(err, "elem")
 			}
 			v.Child = append(v.Child, elem)
 			return nil
 		}); err != nil {
-			return xerrors.Errorf("array: %w", err)
+			return errors.Wrap(err, "array")
 		}
 		return nil
 	}

dec.go

@@ -1,8 +1,9 @@
 package jx
 
 import (
-	"errors"
 	"io"
+
+	"github.com/ogen-go/errors"
 )
 
 // Type the type for JSON element

dec_arr.go

@@ -1,7 +1,7 @@
 package jx
 
 import (
-	"golang.org/x/xerrors"
+	"github.com/ogen-go/errors"
 )
 
 // Elem reads array element and reports whether array has more
@@ -15,7 +15,7 @@ func (d *Decoder) Elem() (ok bool, err error) {
 	case '[':
 		c, err := d.more()
 		if err != nil {
-			return false, xerrors.Errorf("next: %w", err)
+			return false, errors.Wrap(err, "next")
 		}
 		if c != ']' {
 			d.unread()
@@ -27,7 +27,7 @@ func (d *Decoder) Elem() (ok bool, err error) {
 	case ',':
 		return true, nil
 	default:
-		return false, xerrors.Errorf(`"[" or "," or "]" expected: %w`, badToken(c))
+		return false, errors.Wrap(badToken(c), `"[" or "," or "]" expected`)
 	}
 }
 
@@ -39,10 +39,10 @@ func (d *Decoder) Arr(f func(d *Decoder) error) error {
 		f = skipArr
 	}
 	if err := d.consume('['); err != nil {
-		return xerrors.Errorf("start: %w", err)
+		return errors.Wrap(err, "start")
 	}
 	if err := d.incDepth(); err != nil {
-		return xerrors.Errorf("inc: %w", err)
+		return errors.Wrap(err, "inc")
 	}
 	c, err := d.more()
 	if err != nil {
@@ -53,28 +53,28 @@ func (d *Decoder) Arr(f func(d *Decoder) error) error {
 	}
 	d.unread()
 	if err := f(d); err != nil {
-		return xerrors.Errorf("callback: %w", err)
+		return errors.Wrap(err, "callback")
 	}
 
 	c, err = d.more()
 	if err != nil {
-		return xerrors.Errorf("next: %w", err)
+		return errors.Wrap(err, "next")
 	}
 	for c == ',' {
 		// Skip whitespace before reading element.
 		if _, err := d.next(); err != nil {
-			return xerrors.Errorf("next: %w", err)
+			return errors.Wrap(err, "next")
 		}
 		d.unread()
 		if err := f(d); err != nil {
-			return xerrors.Errorf("callback: %w", err)
+			return errors.Wrap(err, "callback")
 		}
 		if c, err = d.next(); err != nil {
-			return xerrors.Errorf("next: %w", err)
+			return errors.Wrap(err, "next")
 		}
 	}
 	if c != ']' {
-		return xerrors.Errorf("end: %w", badToken(c))
+		return errors.Wrap(badToken(c), "end")
 	}
 	return d.decDepth()
 }

dec_capture.go

@@ -1,15 +1,15 @@
 package jx
 
 import (
-	"golang.org/x/xerrors"
+	"github.com/ogen-go/errors"
 )
 
 // Capture calls f and then rolls back to state before call.
 //
 // Does not work with reader.
 func (d *Decoder) Capture(f func(d *Decoder) error) error {
 	if d.reader != nil {
-		return xerrors.New("capture is not supported with reader")
+		return errors.New("capture is not supported with reader")
 	}
 	if f == nil {
 		return nil

dec_float.go

@@ -7,7 +7,7 @@ import (
 	"math/big"
 	"strconv"
 
-	"golang.org/x/xerrors"
+	"github.com/ogen-go/errors"
 )
 
 var pow10 = []uint64{1, 10, 100, 1000, 10000, 100000, 1000000}
@@ -39,15 +39,15 @@ func init() {
 func (d *Decoder) BigFloat() (*big.Float, error) {
 	str, err := d.number(nil)
 	if err != nil {
-		return nil, xerrors.Errorf("number: %w", err)
+		return nil, errors.Wrap(err, "number")
 	}
 	prec := 64
 	if len(str) > prec {
 		prec = len(str)
 	}
 	val, _, err := big.ParseFloat(string(str), 10, uint(prec), big.ToZero)
 	if err != nil {
-		return nil, xerrors.Errorf("float: %w", err)
+		return nil, errors.Wrap(err, "float")
 	}
 	return val, nil
 }
@@ -56,12 +56,12 @@ func (d *Decoder) BigFloat() (*big.Float, error) {
 func (d *Decoder) BigInt() (*big.Int, error) {
 	str, err := d.number(nil)
 	if err != nil {
-		return nil, xerrors.Errorf("number: %w", err)
+		return nil, errors.Wrap(err, "number")
 	}
 	v := big.NewInt(0)
 	var ok bool
 	if v, ok = v.SetString(string(str), 10); !ok {
-		return nil, xerrors.New("invalid")
+		return nil, errors.New("invalid")
 	}
 	return v, nil
 }
@@ -70,7 +70,7 @@ func (d *Decoder) BigInt() (*big.Int, error) {
 func (d *Decoder) Float32() (float32, error) {
 	c, err := d.more()
 	if err != nil {
-		return 0, xerrors.Errorf("byte: %w", err)
+		return 0, errors.Wrap(err, "byte")
 	}
 	if c != '-' {
 		d.unread()
@@ -98,17 +98,17 @@ func (d *Decoder) positiveFloat32() (float32, error) {
 	case invalidCharForNumber:
 		return d.f32Slow()
 	case endOfNumber:
-		return 0, xerrors.New("empty")
+		return 0, errors.New("empty")
 	case dotInNumber:
-		return 0, xerrors.New("leading dot")
+		return 0, errors.New("leading dot")
 	case 0:
 		if i == d.tail {
 			return d.f32Slow()
 		}
 		c = d.buf[i]
 		switch c {
 		case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
-			return 0, xerrors.New("leading zero")
+			return 0, errors.New("leading zero")
 		}
 	}
 	value := uint64(ind)
@@ -201,7 +201,7 @@ func (d *Decoder) f32Slow() (float32, error) {
 func (d *Decoder) Float64() (float64, error) {
 	c, err := d.more()
 	if err != nil {
-		return 0, xerrors.Errorf("byte: %w", err)
+		return 0, errors.Wrap(err, "byte")
 	}
 	if c == '-' {
 		v, err := d.positiveFloat64()
@@ -227,17 +227,17 @@ func (d *Decoder) positiveFloat64() (float64, error) {
 	case invalidCharForNumber:
 		return d.float64Slow()
 	case endOfNumber:
-		return 0, xerrors.New("empty")
+		return 0, errors.New("empty")
 	case dotInNumber:
-		return 0, xerrors.New("leading dot")
+		return 0, errors.New("leading dot")
 	case 0:
 		if i == d.tail {
 			return d.float64Slow()
 		}
 		c = d.buf[i]
 		switch c {
 		case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
-			return 0, xerrors.New("leading zero")
+			return 0, errors.New("leading zero")
 		}
 	}
 	value := uint64(ind)
@@ -299,10 +299,10 @@ func (d *Decoder) floatSlow(size int) (float64, error) {
 
 	str, err := d.number(buf[:0])
 	if err != nil {
-		return 0, xerrors.Errorf("number: %w", err)
+		return 0, errors.Wrap(err, "number")
 	}
 	if err := validateFloat(str); err != nil {
-		return 0, xerrors.Errorf("invalid: %w", err)
+		return 0, errors.Wrap(err, "invalid")
 	}
 
 	val, err := strconv.ParseFloat(string(str), size)
@@ -318,23 +318,23 @@ func (d *Decoder) float64Slow() (float64, error) { return d.floatSlow(size64) }
 func validateFloat(str []byte) error {
 	// strconv.ParseFloat is not validating `1.` or `1.e1`
 	if len(str) == 0 {
-		return xerrors.New("empty")
+		return errors.New("empty")
 	}
 	if str[0] == '-' {
-		return xerrors.New("double minus")
+		return errors.New("double minus")
 	}
 	if len(str) >= 2 && str[0] == '0' && str[1] == '0' {
-		return xerrors.New("leading zero")
+		return errors.New("leading zero")
 	}
 	dotPos := bytes.IndexByte(str, '.')
 	if dotPos != -1 {
 		if dotPos == len(str)-1 {
-			return xerrors.New("dot as last char")
+			return errors.New("dot as last char")
 		}
 		switch str[dotPos+1] {
 		case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
 		default:
-			return xerrors.New("no digit after dot")
+			return errors.New("no digit after dot")
 		}
 	}
 	return nil