Cleanup jsonwire.ParseFloat to simply wrap strconv

Calling strconv.ParseFloat() does not allocate now, so the necessity of fast
path is reduced. This fast path actually slows down the process when it fails.

If overflows, return infinity as all other libs, don't give surprise to user.
Since we now always treat overflow as error, this may not be very important,
but still a breaking change.

Author: huww98

arshal_test.go

@@ -5434,7 +5434,7 @@ func TestUnmarshal(t *testing.T) {
 		name:    jsontest.Name("Floats/Float32/Overflow"),
 		inBuf:   `-1e1000`,
 		inVal:   addr(float32(32.32)),
-		want:    addr(float32(-math.MaxFloat32)),
+		want:    addr(float32(math.Inf(-1))),
 		wantErr: EU(strconv.ErrRange).withVal(`-1e1000`).withType('0', T[float32]()),
 	}, {
 		name:  jsontest.Name("Floats/Float64/Pi"),
@@ -5450,13 +5450,13 @@ func TestUnmarshal(t *testing.T) {
 		name:    jsontest.Name("Floats/Float64/Overflow"),
 		inBuf:   `-1e1000`,
 		inVal:   addr(float64(64.64)),
-		want:    addr(float64(-math.MaxFloat64)),
+		want:    addr(float64(math.Inf(-1))),
 		wantErr: EU(strconv.ErrRange).withVal(`-1e1000`).withType('0', T[float64]()),
 	}, {
 		name:    jsontest.Name("Floats/Any/Overflow"),
 		inBuf:   `1e1000`,
 		inVal:   new(any),
-		want:    addr(any(float64(math.MaxFloat64))),
+		want:    addr(any(math.Inf(+1))),
 		wantErr: EU(strconv.ErrRange).withVal(`1e1000`).withType('0', T[float64]()),
 	}, {
 		name:  jsontest.Name("Floats/Named"),

internal/jsonwire/decode.go

@@ -605,36 +605,7 @@ func ParseUint(b []byte) (v uint64, ok bool) {
 
 // ParseFloat parses a floating point number according to the Go float grammar.
 // Note that the JSON number grammar is a strict subset.
-//
-// If the number overflows the finite representation of a float,
-// then we return MaxFloat since any finite value will always be infinitely
-// more accurate at representing another finite value than an infinite value.
 func ParseFloat(b []byte, bits int) (v float64, ok bool) {
-	// Fast path for exact integer numbers which fit in the
-	// 24-bit or 53-bit significand of a float32 or float64.
-	var negLen int // either 0 or 1
-	if len(b) > 0 && b[0] == '-' {
-		negLen = 1
-	}
-	u, ok := ParseUint(b[negLen:])
-	if ok && ((bits == 32 && u <= 1<<24) || (bits == 64 && u <= 1<<53)) {
-		return math.Copysign(float64(u), float64(-1*negLen)), true
-	}
-
-	// Note that the []byte->string conversion unfortunately allocates.
-	// See https://go.dev/issue/42429 for more information.
 	fv, err := strconv.ParseFloat(string(b), bits)
-	if math.IsInf(fv, 0) {
-		switch {
-		case bits == 32 && math.IsInf(fv, +1):
-			fv = +math.MaxFloat32
-		case bits == 64 && math.IsInf(fv, +1):
-			fv = +math.MaxFloat64
-		case bits == 32 && math.IsInf(fv, -1):
-			fv = -math.MaxFloat32
-		case bits == 64 && math.IsInf(fv, -1):
-			fv = -math.MaxFloat64
-		}
-	}
 	return fv, err == nil
 }

internal/jsonwire/decode_test.go

@@ -421,8 +421,8 @@ func TestParseFloat(t *testing.T) {
 		{"-9007199254740993", -9007199254740992, -9007199254740992, true}, // -(1<<53 + 1)
 		{"9007199254740993", 9007199254740992, 9007199254740992, true},    // +(1<<53 + 1)
 
-		{"-1e1000", -math.MaxFloat32, -math.MaxFloat64, false},
-		{"1e1000", +math.MaxFloat32, +math.MaxFloat64, false},
+		{"-1e1000", math.Inf(-1), math.Inf(-1), false},
+		{"1e1000", math.Inf(+1), math.Inf(+1), false},
 	}
 
 	for _, tt := range tests {

jsontext/token_test.go

@@ -73,8 +73,8 @@ func TestTokenAccessors(t *testing.T) {
 		{Uint(maxUint64 - 1), token{String: "18446744073709551614", Float: maxUint64 - 1, Int: maxInt64, Uint: maxUint64 - 1, Kind: '0'}},
 		{Uint(maxUint64), token{String: "18446744073709551615", Float: maxUint64, Int: maxInt64, Uint: maxUint64, Kind: '0'}},
 		{rawToken(`-0`), token{String: "-0", Float: math.Copysign(0, -1), Int: 0, Uint: 0, Kind: '0'}},
-		{rawToken(`1e1000`), token{String: "1e1000", Float: math.MaxFloat64, Int: maxInt64, Uint: maxUint64, Kind: '0'}},
-		{rawToken(`-1e1000`), token{String: "-1e1000", Float: -math.MaxFloat64, Int: minInt64, Uint: minUint64, Kind: '0'}},
+		{rawToken(`1e1000`), token{String: "1e1000", Float: math.Inf(+1), Int: maxInt64, Uint: maxUint64, Kind: '0'}},
+		{rawToken(`-1e1000`), token{String: "-1e1000", Float: math.Inf(-1), Int: minInt64, Uint: minUint64, Kind: '0'}},
 		{rawToken(`0.1`), token{String: "0.1", Float: 0.1, Int: 0, Uint: 0, Kind: '0'}},
 		{rawToken(`0.5`), token{String: "0.5", Float: 0.5, Int: 0, Uint: 0, Kind: '0'}},
 		{rawToken(`0.9`), token{String: "0.9", Float: 0.9, Int: 0, Uint: 0, Kind: '0'}},