From: Damien Neil Date: Mon, 14 Sep 2020 21:00:52 +0000 (+0000) Subject: Revert "encoding/json: implement Is on all errors" X-Git-Tag: go1.16beta1~1058 X-Git-Url: http://www.git.cypherpunks.su/?a=commitdiff_plain;h=114719e16e9681bd1001326598ededa719c17944;p=gostls13.git Revert "encoding/json: implement Is on all errors" This reverts CL 254537. Reason for revert: Reason for revert: The recommended way to check for a type of error is errors.As. API changes should also start with a proposal. Change-Id: I07c37428575e99c80b17525833a61831d10963bb Reviewed-on: https://go-review.googlesource.com/c/go/+/254857 Trust: Damien Neil Reviewed-by: Emmanuel Odeke --- diff --git a/src/encoding/json/decode.go b/src/encoding/json/decode.go index 1b006ffb17..86d8a69db7 100644 --- a/src/encoding/json/decode.go +++ b/src/encoding/json/decode.go @@ -136,12 +136,6 @@ func (e *UnmarshalTypeError) Error() string { return "json: cannot unmarshal " + e.Value + " into Go value of type " + e.Type.String() } -// Is returns true if target is a UnmarshalTypeError. -func (e *UnmarshalTypeError) Is(target error) bool { - _, ok := target.(*UnmarshalTypeError) - return ok -} - // An UnmarshalFieldError describes a JSON object key that // led to an unexported (and therefore unwritable) struct field. // @@ -156,24 +150,12 @@ func (e *UnmarshalFieldError) Error() string { return "json: cannot unmarshal object key " + strconv.Quote(e.Key) + " into unexported field " + e.Field.Name + " of type " + e.Type.String() } -// Is returns true if target is a UnmarshalFieldError. -func (e *UnmarshalFieldError) Is(target error) bool { - _, ok := target.(*UnmarshalFieldError) - return ok -} - // An InvalidUnmarshalError describes an invalid argument passed to Unmarshal. // (The argument to Unmarshal must be a non-nil pointer.) type InvalidUnmarshalError struct { Type reflect.Type } -// Is returns true if target is a InvalidUnmarshalError. -func (e *InvalidUnmarshalError) Is(target error) bool { - _, ok := target.(*InvalidUnmarshalError) - return ok -} - func (e *InvalidUnmarshalError) Error() string { if e.Type == nil { return "json: Unmarshal(nil)" diff --git a/src/encoding/json/decode_test.go b/src/encoding/json/decode_test.go index b707dcfa99..219e845c7b 100644 --- a/src/encoding/json/decode_test.go +++ b/src/encoding/json/decode_test.go @@ -2572,34 +2572,3 @@ func TestUnmarshalMaxDepth(t *testing.T) { } } } - -func TestInvalidUnmarshalErrorIs(t *testing.T) { - err := fmt.Errorf("apackage: %w: failed to parse struct", &InvalidUnmarshalError{reflect.TypeOf("a")}) - if !errors.Is(err, &InvalidUnmarshalError{}) { - t.Fatalf("%v should be unwrapped to a InvalidUnmarshalError", err) - } -} - -func TestUnmarshalFieldErrorIs(t *testing.T) { - err := fmt.Errorf("apackage: %w: failed to parse struct", &UnmarshalFieldError{ - Key: "foo", - Type: reflect.TypeOf("a"), - Field: reflect.StructField{Name: "b"}, - }) - if !errors.Is(err, &UnmarshalFieldError{}) { - t.Fatalf("%v should be unwrapped to a UnmarshalFieldError", err) - } -} - -func TestUnmarshalTypeErrorIs(t *testing.T) { - err := fmt.Errorf("apackage: %w: failed to parse struct", &UnmarshalTypeError{ - Value: "foo", - Type: reflect.TypeOf("a"), - Offset: 1, - Struct: "Foo", - Field: "Bar", - }) - if !errors.Is(err, &UnmarshalTypeError{}) { - t.Fatalf("%v should be unwrapped to a UnmarshalTypeError", err) - } -} diff --git a/src/encoding/json/encode.go b/src/encoding/json/encode.go index 8e6b342b59..578d551102 100644 --- a/src/encoding/json/encode.go +++ b/src/encoding/json/encode.go @@ -245,12 +245,6 @@ func (e *UnsupportedValueError) Error() string { return "json: unsupported value: " + e.Str } -// Is returns true if target is a UnsupportedValueError. -func (e *UnsupportedValueError) Is(target error) bool { - _, ok := target.(*UnsupportedValueError) - return ok -} - // Before Go 1.2, an InvalidUTF8Error was returned by Marshal when // attempting to encode a string value with invalid UTF-8 sequences. // As of Go 1.2, Marshal instead coerces the string to valid UTF-8 by @@ -285,12 +279,6 @@ func (e *MarshalerError) Error() string { // Unwrap returns the underlying error. func (e *MarshalerError) Unwrap() error { return e.Err } -// Is returns true if target is a MarshalerError. -func (e *MarshalerError) Is(target error) bool { - _, ok := target.(*MarshalerError) - return ok -} - var hex = "0123456789abcdef" // An encodeState encodes JSON into a bytes.Buffer. diff --git a/src/encoding/json/encode_test.go b/src/encoding/json/encode_test.go index 90826a7f47..7290eca06f 100644 --- a/src/encoding/json/encode_test.go +++ b/src/encoding/json/encode_test.go @@ -7,7 +7,6 @@ package json import ( "bytes" "encoding" - "errors" "fmt" "log" "math" @@ -212,7 +211,7 @@ var unsupportedValues = []interface{}{ func TestUnsupportedValues(t *testing.T) { for _, v := range unsupportedValues { if _, err := Marshal(v); err != nil { - if !errors.Is(err, &UnsupportedValueError{}) { + if _, ok := err.(*UnsupportedValueError); !ok { t.Errorf("for %v, got %T want UnsupportedValueError", v, err) } } else { @@ -1156,24 +1155,3 @@ func TestMarshalerError(t *testing.T) { } } } - -func TestMarshalerErrorIs(t *testing.T) { - err := fmt.Errorf("apackage: %w: failed to parse struct", &MarshalerError{ - reflect.TypeOf("a"), - fmt.Errorf("something"), - "TestMarshalerErrorIs", - }) - if !errors.Is(err, &MarshalerError{}) { - t.Fatalf("%v should be unwrapped to a MarshalerError", err) - } -} - -func TestUnsupportedValueErrorIs(t *testing.T) { - err := fmt.Errorf("apackage: %w: failed to parse struct", &UnsupportedValueError{ - Value: reflect.Value{}, - Str: "Foo", - }) - if !errors.Is(err, &UnsupportedValueError{}) { - t.Fatalf("%v should be unwrapped to a UnsupportedValueError", err) - } -}