Fix multiple large int64 handling issues.

- Fix int64 conversion ignoring unsigned int types.
- Throw an error on float64 that don't fit it int64.
- Return 0 for out of range values instead of undefined values.
- Preserve precision on large int strings.

Fixes #428
Fixes #433
Fixes #434
Fixes #435

Author: knadh

koanf.go

@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"encoding"
 	"fmt"
+	"math"
 	"reflect"
 	"sort"
 	"strconv"
@@ -483,17 +484,53 @@ func toInt64(v any) (int64, error) {
 		return int64(i), nil
 	case int64:
 		return i, nil
+	case uint8:
+		return int64(i), nil
+	case uint16:
+		return int64(i), nil
+	case uint32:
+		return int64(i), nil
+	case uint:
+		return uintToInt64(uint64(i))
+	case uint64:
+		return uintToInt64(i)
 	}
 
 	// Force it to a string and try to convert.
-	f, err := strconv.ParseFloat(fmt.Sprintf("%v", v), 64)
+	s := fmt.Sprintf("%v", v)
+
+	// Try parsing as int64 first, and on failure, attempt float64 parsing.
+	// Parsing directly as float64, when the number is beyond its upper limit (2^53)
+	// causes unnecessary precision loss when the value is actually an int.
+	if i, err := strconv.ParseInt(s, 10, 64); err == nil {
+		return i, nil
+	}
+
+	f, err := strconv.ParseFloat(s, 64)
 	if err != nil {
 		return 0, err
 	}
 
+	// int64(f) is undefined for numbers that are out of range and returns different
+	// results on different architectures. float64 cannot exactly represent MaxInt64,
+	// so check against the ACTUAL upper limit of 2^63.
+	// If neither match, return an error instead of the undefined result.
+	if math.IsNaN(f) || f < math.MinInt64 || f >= 1<<63 {
+		return 0, fmt.Errorf("value %v overflows int64", v)
+	}
+
 	return int64(f), nil
 }
 
+// uintToInt64 converts an unsigned integer to int64 and throw an error on overflow.
+func uintToInt64(v uint64) (int64, error) {
+	if v > math.MaxInt64 {
+		return 0, fmt.Errorf("value %d overflows int64", v)
+	}
+
+	return int64(v), nil
+}
+
 // toInt64 takes a `v any` value and if it is a float type,
 // converts and returns a `float64`. If it's any other type, forces it to a
 // string and attempts to get a float out using `strconv.ParseFloat`.

tests/koanf_test.go

@@ -7,6 +7,7 @@ import (
 	"fmt"
 	"log"
 	"maps"
+	"math"
 	"os"
 	"path/filepath"
 	"regexp"
@@ -2108,3 +2109,44 @@ func TestGetNilPointer(t *testing.T) {
 	_, ok = gotSlice.(*[]string)
 	assert.True(ok, "expected type *[]string, got %T", gotSlice)
 }
+
+// TesConvertInt64 tests various int64 conversion/overflow scenarios.
+func TesConvertInt64(t *testing.T) {
+	assert := assert.New(t)
+	k := koanf.New(delim)
+
+	assert.Nil(k.Load(confmap.Provider(map[string]any{
+		// Good values.
+		"int64":     int64(math.MaxInt64),
+		"uint64":    uint64(math.MaxInt64),
+		"strmaxint": "9223372036854775807",
+		"strminint": "-9223372036854775808",
+		"str2p53":   "9007199254740993",
+		"float":     1.9,
+		"minfloat":  float64(math.MinInt64),
+		"strfloat":  "3.7",
+
+		// Overflows.
+		"bigfloat":  float64(math.MaxInt64),
+		"hugefloat": 1e300,
+		"neghuge":   -1e300,
+		"inf":       math.Inf(1),
+		"neginf":    math.Inf(-1),
+		"nan":       math.NaN(),
+		"biguint64": uint64(math.MaxInt64) + 1,
+	}, delim), nil))
+
+	assert.Equal(int64(math.MaxInt64), k.Int64("int64"))
+	assert.Equal(int64(math.MaxInt64), k.Int64("uint64"))
+	assert.Equal(int64(math.MaxInt64), k.Int64("strmaxint"))
+	assert.Equal(int64(math.MinInt64), k.Int64("strminint"))
+	assert.Equal(int64(9007199254740993), k.Int64("str2p53"))
+	assert.Equal(int64(1), k.Int64("float"))
+	assert.Equal(int64(math.MinInt64), k.Int64("minfloat"))
+	assert.Equal(int64(3), k.Int64("strfloat"))
+
+	// Out of range must return 0 and not a wrapped value.
+	for _, key := range []string{"bigfloat", "hugefloat", "neghuge", "inf", "neginf", "nan", "biguint64"} {
+		assert.Equal(int64(0), k.Int64(key), "Int64(%q) must be 0", key)
+	}
+}