go run golang.org/x/tools/go/analysis/passes/modernize/cmd/modernize@…

bench_test.go

@@ -101,7 +101,7 @@ func BenchmarkDecoderDecodeInterfaceAny(b *testing.B) {
 			for i := 0; i < b.N; i++ {
 				r.Seek(0, 0)
 				dec := NewDecoderBuffer(r, buf[:])
-				var i interface{}
+				var i any
 				err := dec.Decode(&i)
 				check(b, err)
 			}
@@ -113,7 +113,7 @@ func BenchmarkDecoderDecodeInterfaceAny(b *testing.B) {
 			for i := 0; i < b.N; i++ {
 				r.Seek(0, 0)
 				dec := json.NewDecoder(r)
-				var i interface{}
+				var i any
 				err := dec.Decode(&i)
 				check(b, err)
 			}

decoder.go

@@ -279,7 +279,7 @@ func (d *Decoder) stateEnd() ([]byte, error) { return nil, io.EOF }
 
 // Decode reads the next JSON-encoded value from its input and stores it
 // in the value pointed to by v.
-func (d *Decoder) Decode(v interface{}) error {
+func (d *Decoder) Decode(v any) error {
 	rv := reflect.ValueOf(v)
 	switch {
 	case rv.Kind() != reflect.Ptr:
@@ -404,7 +404,7 @@ func (d *Decoder) decodeValue(v reflect.Value) error {
 	}
 }
 
-func (d *Decoder) decodeValueAny() (interface{}, error) {
+func (d *Decoder) decodeValueAny() (any, error) {
 	tok, err := d.NextToken()
 	if err != nil {
 		return nil, err
@@ -428,8 +428,8 @@ func (d *Decoder) decodeValueAny() (interface{}, error) {
 	}
 }
 
-func (d *Decoder) decodeMapAny() (map[string]interface{}, error) {
-	m := make(map[string]interface{})
+func (d *Decoder) decodeMapAny() (map[string]any, error) {
+	m := make(map[string]any)
 	for {
 		tok, err := d.NextToken()
 		if err != nil {
@@ -474,8 +474,8 @@ func (d *Decoder) decodeMap(v reflect.Value) error {
 	}
 }
 
-func (d *Decoder) decodeSliceAny() ([]interface{}, error) {
-	s := make([]interface{}, 0, 1)
+func (d *Decoder) decodeSliceAny() ([]any, error) {
+	s := make([]any, 0, 1)
 	for {
 		tok, err := d.NextToken()
 		if err != nil {

decoder_test.go

@@ -113,15 +113,15 @@ func TestDecoderInvalidJSON(t *testing.T) {
 
 func TestDecoderDecode(t *testing.T) {
 
-	assert := func(t *testing.T, v interface{}, want interface{}) {
+	assert := func(t *testing.T, v any, want any) {
 		t.Helper()
 		got := reflect.ValueOf(v).Interface()
 		if !reflect.DeepEqual(want, got) {
 			t.Errorf("expected: %v, got: %v", want, got)
 		}
 	}
 
-	decode := func(t *testing.T, input string, v interface{}) {
+	decode := func(t *testing.T, input string, v any) {
 		t.Helper()
 		dec := NewDecoder(strings.NewReader(input))
 		err := dec.Decode(v)
@@ -143,13 +143,13 @@ func TestDecoderDecode(t *testing.T) {
 	})
 
 	t.Run("bool interface true", func(t *testing.T) {
-		var bi interface{} = false
+		var bi any = false
 		decode(t, "true", &bi)
 		assert(t, bi, true)
 	})
 
 	t.Run("bool interface false", func(t *testing.T) {
-		var bi interface{} = true
+		var bi any = true
 		decode(t, "false", &bi)
 		assert(t, bi, false)
 	})
@@ -173,7 +173,7 @@ func TestDecoderDecode(t *testing.T) {
 	})
 
 	t.Run("float64 interface", func(t *testing.T) {
-		var fi interface{}
+		var fi any
 		decode(t, "3", &fi)
 		assert(t, fi, 3.0)
 	})
@@ -209,39 +209,39 @@ func TestDecoderDecode(t *testing.T) {
 	})
 
 	t.Run("empty object", func(t *testing.T) {
-		var a interface{}
+		var a any
 		decode(t, "{}", &a)
-		assert(t, a, map[string]interface{}{})
+		assert(t, a, map[string]any{})
 	})
 
 	t.Run("nested object", func(t *testing.T) {
-		var a interface{}
+		var a any
 		decode(t, `{"a": 1, "b": {"c": 2}}`, &a)
-		assert(t, a, map[string]interface{}{
+		assert(t, a, map[string]any{
 			"a": float64(1),
-			"b": map[string]interface{}{
+			"b": map[string]any{
 				"c": float64(2),
 			},
 		})
 	})
 
 	t.Run("nested array of objects", func(t *testing.T) {
-		var a interface{}
+		var a any
 		decode(t, `[{"a": [{}]}]`, &a)
-		assert(t, a, []interface{}{
-			map[string]interface{}{
-				"a": []interface{}{
-					map[string]interface{}{},
+		assert(t, a, []any{
+			map[string]any{
+				"a": []any{
+					map[string]any{},
 				},
 			},
 		})
 	})
 
 	t.Run("object key with embedded quote", func(t *testing.T) {
 		t.Skip("known bug: decoder does not unescape backslashes in object keys")
-		var escaped interface{}
+		var escaped any
 		decode(t, `{"a\"b":0}`, &escaped)
-		assert(t, escaped, map[string]interface{}{`a"b`: 0.0})
+		assert(t, escaped, map[string]any{`a"b`: 0.0})
 	})
 
 	t.Run("map string string", func(t *testing.T) {
@@ -253,12 +253,12 @@ func TestDecoderDecode(t *testing.T) {
 	})
 
 	t.Run("map string interface", func(t *testing.T) {
-		mi := make(map[string]interface{})
+		mi := make(map[string]any)
 		decode(t, `{"a": 1, "b": false, "c":[1, 2.0, "three"]}`, &mi)
-		assert(t, mi, map[string]interface{}{
+		assert(t, mi, map[string]any{
 			"a": float64(1),
 			"b": false,
-			"c": []interface{}{
+			"c": []any{
 				float64(1),
 				2.0,
 				"three",

example_test.go

@@ -97,7 +97,7 @@ func ExampleDecoder_NextToken() {
 func ExampleDecoder_Decode() {
 	input := `{"a": 1,"b": 123.456, "c": [null]}`
 	dec := json.NewDecoder(strings.NewReader(input))
-	var i interface{}
+	var i any
 	err := dec.Decode(&i)
 	if err != nil {
 		log.Fatal(err)