Eliminate duplicate type switches (#423)

* Eliminate duplicate type switches

* Only operate on exported fields

* Add test case for unexported

Author: chadweimer

conf/conf.go

@@ -35,13 +35,17 @@ func Bind(ptr any) error {
 
 func bindValue(objVal reflect.Value) error {
 	for i := 0; i < objVal.NumField(); i++ {
+		field := objVal.Type().Field(i)
+		if !field.IsExported() {
+			continue
+		}
+
 		fieldVal := objVal.Field(i)
 		if fieldVal.Kind() == reflect.Struct {
 			if err := bindValue(fieldVal); err != nil {
 				return err
 			}
 		} else {
-			field := objVal.Type().Field(i)
 			if err := setToDefault(field, fieldVal); err != nil {
 				return err
 			}
@@ -92,43 +96,42 @@ func setFromEnv(field reflect.StructField, val reflect.Value) {
 func set(val reflect.Value, str string) error {
 	switch val.Type().Kind() {
 	case reflect.String:
-		typed, _ := getValue(val.Type(), str)
-		val.SetString(typed.(string))
+		val.SetString(str)
 
 	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-		typed, err := getValue(val.Type(), str)
+		typed, err := strconv.ParseInt(str, 10, val.Type().Bits())
 		if err != nil {
 			return err
 		}
-		val.SetInt(typed.(int64))
+		val.SetInt(typed)
 
 	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-		typed, err := getValue(val.Type(), str)
+		typed, err := strconv.ParseUint(str, 10, val.Type().Bits())
 		if err != nil {
 			return err
 		}
-		val.SetUint(typed.(uint64))
+		val.SetUint(typed)
 
 	case reflect.Float32, reflect.Float64:
-		typed, err := getValue(val.Type(), str)
+		typed, err := strconv.ParseFloat(str, val.Type().Bits())
 		if err != nil {
 			return err
 		}
-		val.SetFloat(typed.(float64))
+		val.SetFloat(typed)
 
 	case reflect.Complex64, reflect.Complex128:
-		typed, err := getValue(val.Type(), str)
+		typed, err := strconv.ParseComplex(str, val.Type().Bits())
 		if err != nil {
 			return err
 		}
-		val.SetComplex(typed.(complex128))
+		val.SetComplex(typed)
 
 	case reflect.Bool:
-		typed, err := getValue(val.Type(), str)
+		typed, err := strconv.ParseBool(str)
 		if err != nil {
 			return err
 		}
-		val.SetBool(typed.(bool))
+		val.SetBool(typed)
 
 	case reflect.Array, reflect.Slice:
 		elementType := val.Type().Elem()
@@ -156,47 +159,3 @@ func set(val reflect.Value, str string) error {
 
 	return nil
 }
-
-func getValue(fieldType reflect.Type, str string) (any, error) {
-	switch fieldType.Kind() {
-	case reflect.String:
-		return str, nil
-
-	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-		typed, err := strconv.ParseInt(str, 10, fieldType.Bits())
-		if err != nil {
-			return nil, err
-		}
-		return typed, nil
-
-	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-		typed, err := strconv.ParseUint(str, 10, fieldType.Bits())
-		if err != nil {
-			return nil, err
-		}
-		return typed, nil
-
-	case reflect.Float32, reflect.Float64:
-		typed, err := strconv.ParseFloat(str, fieldType.Bits())
-		if err != nil {
-			return nil, err
-		}
-		return typed, nil
-
-	case reflect.Complex64, reflect.Complex128:
-		typed, err := strconv.ParseComplex(str, fieldType.Bits())
-		if err != nil {
-			return nil, err
-		}
-		return typed, nil
-
-	case reflect.Bool:
-		typed, err := strconv.ParseBool(str)
-		if err != nil {
-			return nil, err
-		}
-		return typed, nil
-	}
-
-	return nil, errUnsupportedType{fieldType}
-}

conf/conf_test.go

@@ -18,6 +18,8 @@ func TestBind_Defaults(t *testing.T) {
 		TestIntPtr   *int  `default:"-1"`
 	}
 	type allSupportedTypes struct {
+		unexportedInt int `default:"5"`
+
 		TestInts intTypes
 
 		TestUint      uint   `default:"1"`
@@ -46,6 +48,8 @@ func TestBind_Defaults(t *testing.T) {
 		{
 			name: "Defaults are set",
 			want: allSupportedTypes{
+				unexportedInt: 0, // Should be ignored, not set
+
 				TestInts: intTypes{
 					TestInt:      -1,
 					TestInt8:     -2,