update remaining gruf libraries relying on linkname (#3028)

2 files changed, 34 insertions, 75 deletions

diff --git a/vendor/codeberg.org/gruf/go-bytesize/bytesize.go b/vendor/codeberg.org/gruf/go-bytesize/bytesize.go
index 939397939..d24ff5f0f 100644
--- a/vendor/codeberg.org/gruf/go-bytesize/bytesize.go
+++ b/vendor/codeberg.org/gruf/go-bytesize/bytesize.go
@@ -3,7 +3,7 @@ package bytesize
 import (
 	"errors"
 	"math/bits"
-	_ "strconv"
+	"strconv"
 	"unsafe"
 )
 
@@ -102,10 +102,10 @@ func ParseSize(s string) (Size, error) {
 		return 0, err
 	}
 
-	// Parse remaining string as float
-	f, n, err := atof64(s[:l])
-	if err != nil || n != l {
-		return 0, ErrInvalidFormat
+	// Parse remaining string as 64bit float
+	f, err := strconv.ParseFloat(s[:l], 64)
+	if err != nil {
+		return 0, errctx(ErrInvalidFormat, err.Error())
 	}
 
 	return Size(f * unit), nil
@@ -236,7 +236,7 @@ func parseUnit(s string) (float64, int, error) {
 
 		// Check valid unit char was provided
 		if len(iecvals) < c || iecvals[c] == 0 {
-			return 0, 0, ErrInvalidUnit
+			return 0, 0, errctx(ErrInvalidUnit, s[l:])
 		}
 
 		// Return parsed IEC unit size
@@ -250,7 +250,7 @@ func parseUnit(s string) (float64, int, error) {
 	switch {
 	// Check valid unit char provided
 	case len(sivals) < c || sivals[c] == 0:
-		return 0, 0, ErrInvalidUnit
+		return 0, 0, errctx(ErrInvalidUnit, s[l:])
 
 	// No unit char (only ascii number)
 	case sivals[c] == 1:
@@ -349,10 +349,21 @@ func itoa(dst []byte, i uint64) []byte {
 	return append(dst, b[bp:]...)
 }
 
-// We use the following internal strconv function usually
-// used internally to parse float values, as we know that
-// are value passed will always be of 64bit type, and knowing
-// the returned float string length is very helpful!
-//
-//go:linkname atof64 strconv.atof64
-func atof64(string) (float64, int, error)
+// errwithctx wraps an error
+// with extra context info.
+type errwithctx struct {
+	err error
+	ctx string
+}
+
+func errctx(err error, ctx string) error {
+	return &errwithctx{err: err, ctx: ctx}
+}
+
+func (err *errwithctx) Unwrap() error {
+	return err.err
+}
+
+func (err *errwithctx) Error() string {
+	return err.err.Error() + ": " + err.ctx
+}
diff --git a/vendor/codeberg.org/gruf/go-errors/v2/standard.go b/vendor/codeberg.org/gruf/go-errors/v2/standard.go
index 3739416dc..e1d7d1440 100644
--- a/vendor/codeberg.org/gruf/go-errors/v2/standard.go
+++ b/vendor/codeberg.org/gruf/go-errors/v2/standard.go
@@ -1,29 +1,11 @@
 package errors
 
 import (
-	_ "unsafe"
+	"errors"
 )
 
-// Is reports whether any error in err's tree matches target.
-//
-// The tree consists of err itself, followed by the errors obtained by repeatedly
-// calling Unwrap. When err wraps multiple errors, Is examines err followed by a
-// depth-first traversal of its children.
-//
-// An error is considered to match a target if it is equal to that target or if
-// it implements a method Is(error) bool such that Is(target) returns true.
-//
-// An error type might provide an Is method so it can be treated as equivalent
-// to an existing error. For example, if MyError defines
-//
-//	func (m MyError) Is(target error) bool { return target == fs.ErrExist }
-//
-// then Is(MyError{}, fs.ErrExist) returns true. See [syscall.Errno.Is] for
-// an example in the standard library. An Is method should only shallowly
-// compare err and the target and not call Unwrap on either.
-//
-//go:linkname Is errors.Is
-func Is(err error, target error) bool
+// See: errors.Is().
+func Is(err error, target error) bool { return errors.Is(err, target) }
 
 // IsV2 calls Is(err, target) for each target within targets.
 func IsV2(err error, targets ...error) bool {
@@ -35,26 +17,8 @@ func IsV2(err error, targets ...error) bool {
 	return false
 }
 
-// As finds the first error in err's tree that matches target, and if one is found, sets
-// target to that error value and returns true. Otherwise, it returns false.
-//
-// The tree consists of err itself, followed by the errors obtained by repeatedly
-// calling Unwrap. When err wraps multiple errors, As examines err followed by a
-// depth-first traversal of its children.
-//
-// An error matches target if the error's concrete value is assignable to the value
-// pointed to by target, or if the error has a method As(interface{}) bool such that
-// As(target) returns true. In the latter case, the As method is responsible for
-// setting target.
-//
-// An error type might provide an As method so it can be treated as if it were a
-// different error type.
-//
-// As panics if target is not a non-nil pointer to either a type that implements
-// error, or to any interface type.
-//
-//go:linkname As errors.As
-func As(err error, target any) bool
+// See: errors.As().
+func As(err error, target any) bool { return errors.As(err, target) }
 
 // AsV2 is functionally similar to As(), instead
 // leveraging generics to handle allocation and
@@ -97,15 +61,8 @@ func AsV2[Type any](err error) Type {
 	return t
 }
 
-// Unwrap returns the result of calling the Unwrap method on err, if err's
-// type contains an Unwrap method returning error.
-// Otherwise, Unwrap returns nil.
-//
-// Unwrap only calls a method of the form "Unwrap() error".
-// In particular Unwrap does not unwrap errors returned by [Join].
-//
-//go:linkname Unwrap errors.Unwrap
-func Unwrap(err error) error
+// See: errors.Unwrap().
+func Unwrap(err error) error { return errors.Unwrap(err) }
 
 // UnwrapV2 is functionally similar to Unwrap(), except that
 // it also handles the case of interface{ Unwrap() []error }.
@@ -121,14 +78,5 @@ func UnwrapV2(err error) []error {
 	return nil
 }
 
-// Join returns an error that wraps the given errors.
-// Any nil error values are discarded.
-// Join returns nil if every value in errs is nil.
-// The error formats as the concatenation of the strings obtained
-// by calling the Error method of each element of errs, with a newline
-// between each string.
-//
-// A non-nil error returned by Join implements the Unwrap() []error method.
-//
-//go:linkname Join errors.Join
-func Join(errs ...error) error
+// See: errors.Join().
+func Join(errs ...error) error { return errors.Join(errs...) }