Preserve input type.

diff --git a/common/math/math.go b/common/math/math.go
index d4e2c1148e6a08a124c270f256f3012bb33dec96..f88fbcd9cb6c7df6c12f5160ac410f4cf632a8c7 100644 (file)
--- a/common/math/math.go
+++ b/common/math/math.go
@@ -26,29 +26,32 @@ func DoArithmetic(a, b any, op rune) (any, error) {
        var ai, bi int64
        var af, bf float64
        var au, bu uint64
+       var isInt, isFloat, isUint bool
        switch av.Kind() {
        case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
                ai = av.Int()
                switch bv.Kind() {
                case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+                       isInt = true
                        bi = bv.Int()
                case reflect.Float32, reflect.Float64:
+                       isFloat = true
                        af = float64(ai) // may overflow
-                       ai = 0
                        bf = bv.Float()
                case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
                        bu = bv.Uint()
                        if ai >= 0 {
+                               isUint = true
                                au = uint64(ai)
-                               ai = 0
                        } else {
+                               isInt = true
                                bi = int64(bu) // may overflow
-                               bu = 0
                        }
                default:
                        return nil, errors.New("can't apply the operator to the values")
                }
        case reflect.Float32, reflect.Float64:
+               isFloat = true
                af = av.Float()
                switch bv.Kind() {
                case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
@@ -66,17 +69,18 @@ func DoArithmetic(a, b any, op rune) (any, error) {
                case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
                        bi = bv.Int()
                        if bi >= 0 {
+                               isUint = true
                                bu = uint64(bi)
-                               bi = 0
                        } else {
+                               isInt = true
                                ai = int64(au) // may overflow
-                               au = 0
                        }
                case reflect.Float32, reflect.Float64:
+                       isFloat = true
                        af = float64(au) // may overflow
-                       au = 0
                        bf = bv.Float()
                case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+                       isUint = true
                        bu = bv.Uint()
                default:
                        return nil, errors.New("can't apply the operator to the values")
@@ -94,38 +98,32 @@ func DoArithmetic(a, b any, op rune) (any, error) {
 
        switch op {
        case '+':
-               if ai != 0 || bi != 0 {
+               if isInt {
                        return ai + bi, nil
-               } else if af != 0 || bf != 0 {
+               } else if isFloat {
                        return af + bf, nil
-               } else if au != 0 || bu != 0 {
-                       return au + bu, nil
                }
-               return 0, nil
+               return au + bu, nil
        case '-':
-               if ai != 0 || bi != 0 {
+               if isInt {
                        return ai - bi, nil
-               } else if af != 0 || bf != 0 {
+               } else if isFloat {
                        return af - bf, nil
-               } else if au != 0 || bu != 0 {
-                       return au - bu, nil
                }
-               return 0, nil
+               return au - bu, nil
        case '*':
-               if ai != 0 || bi != 0 {
+               if isInt {
                        return ai * bi, nil
-               } else if af != 0 || bf != 0 {
+               } else if isFloat {
                        return af * bf, nil
-               } else if au != 0 || bu != 0 {
-                       return au * bu, nil
                }
-               return 0, nil
+               return au * bu, nil
        case '/':
-               if bi != 0 {
+               if isInt && bi != 0 {
                        return ai / bi, nil
-               } else if bf != 0 {
+               } else if isFloat && bf != 0 {
                        return af / bf, nil
-               } else if bu != 0 {
+               } else if isUint && bu != 0 {
                        return au / bu, nil
                }
                return nil, errors.New("can't divide the value by 0")

diff --git a/common/math/math_test.go b/common/math/math_test.go
index 89e391ce000b26a01b29ae3fef51368851a2cf47..d75d30a699925f92d6696ede359f928e9a0e54d8 100644 (file)
--- a/common/math/math_test.go
+++ b/common/math/math_test.go
@@ -30,10 +30,12 @@ func TestDoArithmetic(t *testing.T) {
                expect any
        }{
                {3, 2, '+', int64(5)},
+               {0, 0, '+', int64(0)},
                {3, 2, '-', int64(1)},
                {3, 2, '*', int64(6)},
                {3, 2, '/', int64(1)},
                {3.0, 2, '+', float64(5)},
+               {0.0, 0, '+', float64(0.0)},
                {3.0, 2, '-', float64(1)},
                {3.0, 2, '*', float64(6)},
                {3.0, 2, '/', float64(1.5)},
@@ -42,18 +44,22 @@ func TestDoArithmetic(t *testing.T) {
                {3, 2.0, '*', float64(6)},
                {3, 2.0, '/', float64(1.5)},
                {3.0, 2.0, '+', float64(5)},
+               {0.0, 0.0, '+', float64(0.0)},
                {3.0, 2.0, '-', float64(1)},
                {3.0, 2.0, '*', float64(6)},
                {3.0, 2.0, '/', float64(1.5)},
                {uint(3), uint(2), '+', uint64(5)},
+               {uint(0), uint(0), '+', uint64(0)},
                {uint(3), uint(2), '-', uint64(1)},
                {uint(3), uint(2), '*', uint64(6)},
                {uint(3), uint(2), '/', uint64(1)},
                {uint(3), 2, '+', uint64(5)},
+               {uint(0), 0, '+', uint64(0)},
                {uint(3), 2, '-', uint64(1)},
                {uint(3), 2, '*', uint64(6)},
                {uint(3), 2, '/', uint64(1)},
                {3, uint(2), '+', uint64(5)},
+               {0, uint(0), '+', uint64(0)},
                {3, uint(2), '-', uint64(1)},
                {3, uint(2), '*', uint64(6)},
                {3, uint(2), '/', uint64(1)},
@@ -66,16 +72,15 @@ func TestDoArithmetic(t *testing.T) {
                {-3, uint(2), '*', int64(-6)},
                {-3, uint(2), '/', int64(-1)},
                {uint(3), 2.0, '+', float64(5)},
+               {uint(0), 0.0, '+', float64(0)},
                {uint(3), 2.0, '-', float64(1)},
                {uint(3), 2.0, '*', float64(6)},
                {uint(3), 2.0, '/', float64(1.5)},
                {3.0, uint(2), '+', float64(5)},
+               {0.0, uint(0), '+', float64(0)},
                {3.0, uint(2), '-', float64(1)},
                {3.0, uint(2), '*', float64(6)},
                {3.0, uint(2), '/', float64(1.5)},
-               {0, 0, '+', 0},
-               {0, 0, '-', 0},
-               {0, 0, '*', 0},
                {"foo", "bar", '+', "foobar"},
                {3, 0, '/', false},
                {3.0, 0, '/', false},