cue: fix decoding into big.Float

cue decodes a value into big.Float with big.Float.MarshalText
incorrectly and returns an error if the value can not be represented
by a float64.

This adds the Float method to cue.Value for converting a number into
big.Float and decodes a value into big.Float if it cannot be
represented by float64.

Fixes #3927

Change-Id: Ia81518bd06d8e8566a66f46f0d56006919ff75d7
Signed-off-by: haoqixu <[email protected]>
Reviewed-on: https://review.gerrithub.io/c/cue-lang/cue/+/1215548
Unity-Result: CUE porcuepine <[email protected]>
Reviewed-by: Roger Peppe <[email protected]>
TryBot-Result: CUEcueckoo <[email protected]>

Author: haoqixu

cue/decode.go

@@ -19,6 +19,7 @@ import (
 	"cmp"
 	"encoding"
 	"encoding/json"
+	"math/big"
 	"reflect"
 	"slices"
 	"strconv"
@@ -125,6 +126,17 @@ func (d *decoder) decode(x reflect.Value, v Value, isPtr bool) {
 	}
 
 	if it != nil {
+		if _, ok := it.(*big.Float); ok {
+			f, err := v.Float(nil)
+			if err != nil {
+				err = errors.Wrapf(err, v.Pos(), "Decode")
+				d.addErr(err)
+				return
+			}
+			x.Elem().Set(reflect.ValueOf(*f))
+			return
+		}
+
 		b, err := v.Bytes()
 		if err != nil {
 			err = errors.Wrapf(err, v.Pos(), "Decode")
@@ -273,7 +285,10 @@ func (d *decoder) interfaceValue(v Value) (x interface{}) {
 		x, err = v.Int(nil)
 
 	case FloatKind:
-		x, err = v.Float64() // or big int or
+		if f, err := v.Float64(); err == nil {
+			return f
+		} // or big int or
+		x, err = v.Float(nil)
 
 	case StringKind:
 		x, err = v.String()
@@ -895,11 +910,11 @@ func indirect(v reflect.Value, decodingNull bool) (json.Unmarshaler, encoding.Te
 		}
 		if v.Type().NumMethod() > 0 && v.CanInterface() {
 			if u, ok := v.Interface().(json.Unmarshaler); ok {
-				return u, nil, reflect.Value{}
+				return u, nil, v
 			}
 			if !decodingNull {
 				if u, ok := v.Interface().(encoding.TextUnmarshaler); ok {
-					return nil, u, reflect.Value{}
+					return nil, u, v
 				}
 			}
 		}

cue/decode_test.go

@@ -285,27 +285,21 @@ func TestDecode(t *testing.T) {
 		dst:   new(interface{}),
 		want:  float64(1.797693134e+308),
 	}, {
-		// even larger float which doesn't fit into a float64
-		// TODO(mvdan): this should work via *big.Float, just like we do with *big.Int above.
 		value: `1.99769313499e+508`,
 		dst:   new(interface{}),
-		err:   "value was rounded up",
+		want:  bigFloat(`1.99769313499e+508`),
 	}, {
-		// same as the above, but negative
-		// TODO(mvdan): this should work via *big.Float, just like we do with *big.Int above.
 		value: `-1.99769313499e+508`,
 		dst:   new(interface{}),
-		err:   "value was rounded down",
+		want:  bigFloat(`-1.99769313499e+508`),
 	}, {
-		// TODO: this should work.
 		value: `1.99769313499e+508`,
 		dst:   new(*big.Float),
-		err:   "Decode: cannot use value 1.99769313499E+508 (type float) as (string|bytes)",
+		want:  bigFloat(`1.99769313499e+508`),
 	}, {
-		// TODO: this should work.
 		value: `-1.99769313499e+508`,
 		dst:   new(*big.Float),
-		err:   "Decode: cannot use value -1.99769313499E+508 (type float) as (string|bytes)",
+		want:  bigFloat(`-1.99769313499e+508`),
 	}}
 	for _, tc := range testCases {
 		cuetdtest.FullMatrix.Run(t, tc.value, func(t *testing.T, m *cuetdtest.M) {
@@ -315,6 +309,8 @@ func TestDecode(t *testing.T) {
 			got := reflect.ValueOf(tc.dst).Elem().Interface()
 			if diff := cmp.Diff(got, tc.want, cmp.Comparer(func(a, b *big.Int) bool {
 				return a.Cmp(b) == 0
+			}), cmp.Comparer(func(a, b *big.Float) bool {
+				return a.Cmp(b) == 0
 			})); diff != "" {
 				t.Error(diff)
 				t.Errorf("\n%#v\n%#v", got, tc.want)
@@ -328,6 +324,12 @@ func bigInt(s string) *big.Int {
 	return n
 }
 
+func bigFloat(s string) *big.Float {
+	f := &big.Float{}
+	f, _, _ = f.Parse(s, 0)
+	return f
+}
+
 func TestDecodeIntoCUEValue(t *testing.T) {
 	cuetdtest.FullMatrix.Do(t, func(t *testing.T, m *cuetdtest.M) {
 		// We should be able to decode into a CUE value so we can

cue/types.go

@@ -491,6 +491,24 @@ func init() {
 	}
 }
 
+// Float returns a big.Float nearest to x. It reports an error if v is
+// not a number. If a non-nil *Float argument f is provided, Float stores the result in f
+// instead of allocating a new Float.
+func (v Value) Float(f *big.Float) (*big.Float, error) {
+	var err error
+
+	n, err := v.getNum(adt.NumberKind)
+	if err != nil {
+		return nil, err
+	}
+	if f == nil {
+		f = &big.Float{}
+	}
+
+	f, _, err = f.Parse(n.X.String(), 0)
+	return f, err
+}
+
 // Float64 returns the float64 value nearest to x. It reports an error if v is
 // not a number. If x is too small to be represented by a float64 (|x| <
 // math.SmallestNonzeroFloat64), the result is (0, ErrBelow) or (-0, ErrAbove),

cue/types_test.go

@@ -581,6 +581,74 @@ func TestFloat(t *testing.T) {
 	}
 }
 
+func TestBigFloat(t *testing.T) {
+	testCases := []struct {
+		value    string
+		bigFloat *big.Float
+		kind     cue.Kind
+		err      string
+	}{{
+		value:    "1",
+		bigFloat: bigFloat("1"),
+		kind:     cue.IntKind,
+	}, {
+		value:    "-1",
+		bigFloat: bigFloat("-1"),
+		kind:     cue.IntKind,
+	}, {
+		value:    "0.0",
+		bigFloat: bigFloat("0.0"),
+		kind:     cue.FloatKind,
+	}, {
+		value:    "1.0",
+		bigFloat: bigFloat("1.0"),
+		kind:     cue.FloatKind,
+	}, {
+		value:    "2.6",
+		bigFloat: bigFloat("2.6"),
+		kind:     cue.FloatKind,
+	}, {
+		value:    "20.600",
+		bigFloat: bigFloat("20.600"),
+		kind:     cue.FloatKind,
+	}, {
+		value:    "1/0",
+		bigFloat: nil,
+		err:      "division by zero",
+		kind:     cue.BottomKind,
+	}, {
+		value:    "1.797693134862315708145274237317043567982e+308",
+		bigFloat: bigFloat("1.797693134862315708145274237317043567982e+308"),
+		kind:     cue.FloatKind,
+	}, {
+		value:    "-1.797693134862315708145274237317043567982e+308",
+		bigFloat: bigFloat("-1.797693134862315708145274237317043567982e+308"),
+		kind:     cue.FloatKind,
+	}, {
+		value:    "4.940656458412465441765687928682213723650e-324",
+		bigFloat: bigFloat("4.940656458412465441765687928682213723650e-324"),
+		kind:     cue.FloatKind,
+	}, {
+		value:    "-4.940656458412465441765687928682213723650e-324",
+		bigFloat: bigFloat("-4.940656458412465441765687928682213723650e-324"),
+		kind:     cue.FloatKind,
+	}}
+	for _, tc := range testCases {
+		cuetdtest.FullMatrix.Run(t, tc.value, func(t *testing.T, m *cuetdtest.M) {
+			n := getValue(m, tc.value)
+			if n.Kind() != tc.kind {
+				t.Fatal("Not a number")
+			}
+
+			bf, err := n.Float(nil)
+			checkErr(t, err, tc.err, "Float")
+			if bf != nil && bf.Cmp(tc.bigFloat) != 0 {
+				t.Errorf("Float: got %v; want %v", bf, tc.bigFloat)
+			}
+		})
+	}
+}
+
 func TestString(t *testing.T) {
 	testCases := []struct {
 		value string