Use type switch (#5122)

modules/base/tool.go

 	var rleft, rright int64
 	var fleft, fright float64
 	var isInt = true
-	switch left.(type) {
+	switch left := left.(type) {
 	case int:
-		rleft = int64(left.(int))
+		rleft = int64(left)
 	case int8:
-		rleft = int64(left.(int8))
+		rleft = int64(left)
 	case int16:
-		rleft = int64(left.(int16))
+		rleft = int64(left)
 	case int32:
-		rleft = int64(left.(int32))
+		rleft = int64(left)
 	case int64:
-		rleft = left.(int64)
+		rleft = left
 	case float32:
-		fleft = float64(left.(float32))
+		fleft = float64(left)
 		isInt = false
 	case float64:
-		fleft = left.(float64)
+		fleft = left
 		isInt = false
 	}
 
-	switch right.(type) {
+	switch right := right.(type) {
 	case int:
-		rright = int64(right.(int))
+		rright = int64(right)
 	case int8:
-		rright = int64(right.(int8))
+		rright = int64(right)
 	case int16:
-		rright = int64(right.(int16))
+		rright = int64(right)
 	case int32:
-		rright = int64(right.(int32))
+		rright = int64(right)
 	case int64:
-		rright = right.(int64)
+		rright = right
 	case float32:
-		fright = float64(right.(float32))
+		fright = float64(right)
 		isInt = false
 	case float64:
-		fright = right.(float64)
+		fright = right
 		isInt = false
 	}
 

modules/base/tool_test.go

 
 func TestSubtract(t *testing.T) {
 	toFloat64 := func(n interface{}) float64 {
-		switch n.(type) {
+		switch n := n.(type) {
 		case int:
-			return float64(n.(int))
+			return float64(n)
 		case int8:
-			return float64(n.(int8))
+			return float64(n)
 		case int16:
-			return float64(n.(int16))
+			return float64(n)
 		case int32:
-			return float64(n.(int32))
+			return float64(n)
 		case int64:
-			return float64(n.(int64))
+			return float64(n)
 		case float32:
-			return float64(n.(float32))
+			return float64(n)
 		case float64:
-			return n.(float64)
+			return n
 		default:
 			return 0.0
 		}