golangci-lint (#530)

targets.go

@@ -1,6 +1,7 @@
 package toml
 
 import (
+	"errors"
 	"fmt"
 	"math"
 	"reflect"
@@ -38,26 +39,31 @@ func (t valueTarget) get() reflect.Value {
 
 func (t valueTarget) set(v reflect.Value) error {
 	reflect.Value(t).Set(v)
+
 	return nil
 }
 
 func (t valueTarget) setString(v string) error {
 	t.get().SetString(v)
+
 	return nil
 }
 
 func (t valueTarget) setBool(v bool) error {
 	t.get().SetBool(v)
+
 	return nil
 }
 
 func (t valueTarget) setInt64(v int64) error {
 	t.get().SetInt(v)
+
 	return nil
 }
 
 func (t valueTarget) setFloat64(v float64) error {
 	t.get().SetFloat(v)
+
 	return nil
 }
 
@@ -71,23 +77,48 @@ func (t interfaceTarget) get() reflect.Value {
 }
 
 func (t interfaceTarget) set(v reflect.Value) error {
-	return t.x.set(v)
+	err := t.x.set(v)
+	if err != nil {
+		return fmt.Errorf("interfaceTarget set: %w", err)
+	}
+
+	return nil
 }
 
 func (t interfaceTarget) setString(v string) error {
-	return t.x.setString(v)
+	err := t.x.setString(v)
+	if err != nil {
+		return fmt.Errorf("interfaceTarget setString: %w", err)
+	}
+
+	return nil
 }
 
 func (t interfaceTarget) setBool(v bool) error {
-	return t.x.setBool(v)
+	err := t.x.setBool(v)
+	if err != nil {
+		return fmt.Errorf("interfaceTarget setBool: %w", err)
+	}
+
+	return nil
 }
 
 func (t interfaceTarget) setInt64(v int64) error {
-	return t.x.setInt64(v)
+	err := t.x.setInt64(v)
+	if err != nil {
+		return fmt.Errorf("interfaceTarget setInt64: %w", err)
+	}
+
+	return nil
 }
 
 func (t interfaceTarget) setFloat64(v float64) error {
-	return t.x.setFloat64(v)
+	err := t.x.setFloat64(v)
+	if err != nil {
+		return fmt.Errorf("interfaceTarget setFloat64: %w", err)
+	}
+
+	return nil
 }
 
 // mapTarget targets a specific key of a map.
@@ -102,6 +133,7 @@ func (t mapTarget) get() reflect.Value {
 
 func (t mapTarget) set(v reflect.Value) error {
 	t.v.SetMapIndex(t.k, v)
+
 	return nil
 }
 
@@ -121,6 +153,12 @@ func (t mapTarget) setFloat64(v float64) error {
 	return t.set(reflect.ValueOf(v))
 }
 
+var (
+	errValIndexExpectingSlice  = errors.New("expecting a slice")
+	errValIndexCannotInitSlice = errors.New("cannot initialize a slice")
+)
+
+//nolint:cyclop
 // makes sure that the value pointed at by t is indexable (Slice, Array), or
 // dereferences to an indexable (Ptr, Interface).
 func ensureValueIndexable(t target) error {
@@ -129,159 +167,319 @@ func ensureValueIndexable(t target) error {
 	switch f.Type().Kind() {
 	case reflect.Slice:
 		if f.IsNil() {
-			return t.set(reflect.MakeSlice(f.Type(), 0, 0))
+			err := t.set(reflect.MakeSlice(f.Type(), 0, 0))
+			if err != nil {
+				return fmt.Errorf("ensureValueIndexable: %w", err)
+			}
+
+			return nil
 		}
 	case reflect.Interface:
 		if f.IsNil() || f.Elem().Type() != sliceInterfaceType {
-			return t.set(reflect.MakeSlice(sliceInterfaceType, 0, 0))
+			err := t.set(reflect.MakeSlice(sliceInterfaceType, 0, 0))
+			if err != nil {
+				return fmt.Errorf("ensureValueIndexable: %w", err)
+			}
+
+			return nil
 		}
+
 		if f.Elem().Type().Kind() != reflect.Slice {
-			return fmt.Errorf("interface is pointing to a %s, not a slice", f.Kind())
+			return fmt.Errorf("ensureValueIndexable: %w, not a %s", errValIndexExpectingSlice, f.Kind())
 		}
 	case reflect.Ptr:
 		if f.IsNil() {
 			ptr := reflect.New(f.Type().Elem())
+
 			err := t.set(ptr)
 			if err != nil {
-				return err
+				return fmt.Errorf("ensureValueIndexable: %w", err)
 			}
+
 			f = t.get()
 		}
+
 		return ensureValueIndexable(valueTarget(f.Elem()))
 	case reflect.Array:
 		// arrays are always initialized.
 	default:
-		return fmt.Errorf("cannot initialize a slice in %s", f.Kind())
+		return fmt.Errorf("ensureValueIndexable: %w with %s", errValIndexCannotInitSlice, f.Kind())
 	}
+
 	return nil
 }
 
-var sliceInterfaceType = reflect.TypeOf([]interface{}{})
-var mapStringInterfaceType = reflect.TypeOf(map[string]interface{}{})
+var (
+	sliceInterfaceType     = reflect.TypeOf([]interface{}{})
+	mapStringInterfaceType = reflect.TypeOf(map[string]interface{}{})
+)
 
-func ensureMapIfInterface(x target) {
+func ensureMapIfInterface(x target) error {
 	v := x.get()
+
 	if v.Kind() == reflect.Interface && v.IsNil() {
 		newElement := reflect.MakeMap(mapStringInterfaceType)
-		x.set(newElement)
+
+		err := x.set(newElement)
+		if err != nil {
+			return fmt.Errorf("ensureMapIfInterface: %w", err)
+		}
 	}
+
+	return nil
 }
 
+var errSetStringCannotAssignString = errors.New("cannot assign string")
+
 func setString(t target, v string) error {
 	f := t.get()
 
 	switch f.Kind() {
 	case reflect.String:
-		return t.setString(v)
+		err := t.setString(v)
+		if err != nil {
+			return fmt.Errorf("setString: %w", err)
+		}
+
+		return nil
 	case reflect.Interface:
-		return t.set(reflect.ValueOf(v))
+		err := t.set(reflect.ValueOf(v))
+		if err != nil {
+			return fmt.Errorf("setString: %w", err)
+		}
+
+		return nil
 	default:
-		return fmt.Errorf("cannot assign string to a %s", f.Kind())
+		return fmt.Errorf("setString: %w to a %s", errSetStringCannotAssignString, f.Kind())
 	}
 }
 
+var errSetBoolCannotAssignBool = errors.New("cannot assign bool")
+
 func setBool(t target, v bool) error {
 	f := t.get()
 
 	switch f.Kind() {
 	case reflect.Bool:
-		return t.setBool(v)
+		err := t.setBool(v)
+		if err != nil {
+			return fmt.Errorf("setBool: %w", err)
+		}
+
+		return nil
 	case reflect.Interface:
-		return t.set(reflect.ValueOf(v))
+		err := t.set(reflect.ValueOf(v))
+		if err != nil {
+			return fmt.Errorf("setBool: %w", err)
+		}
+
+		return nil
 	default:
-		return fmt.Errorf("cannot assign bool to a %s", f.String())
+		return fmt.Errorf("setBool: %w to a %s", errSetBoolCannotAssignBool, f.String())
 	}
 }
 
-const maxInt = int64(^uint(0) >> 1)
-const minInt = -maxInt - 1
+const (
+	maxInt = int64(^uint(0) >> 1)
+	minInt = -maxInt - 1
+)
 
+var (
+	errSetInt64InInt32     = errors.New("does not fit in an int32")
+	errSetInt64InInt16     = errors.New("does not fit in an int16")
+	errSetInt64InInt8      = errors.New("does not fit in an int8")
+	errSetInt64InInt       = errors.New("does not fit in an int")
+	errSetInt64InUint64    = errors.New("negative integer does not fit in an uint64")
+	errSetInt64InUint32    = errors.New("negative integer does not fit in an uint32")
+	errSetInt64InUint32Max = errors.New("integer does not fit in an uint32")
+	errSetInt64InUint16    = errors.New("negative integer does not fit in an uint16")
+	errSetInt64InUint16Max = errors.New("integer does not fit in an uint16")
+	errSetInt64InUint8     = errors.New("negative integer does not fit in an uint8")
+	errSetInt64InUint8Max  = errors.New("integer does not fit in an uint8")
+	errSetInt64InUint      = errors.New("negative integer does not fit in an uint")
+	errSetInt64Unknown     = errors.New("does not fit in an uint")
+)
+
+//nolint:funlen,gocognit,cyclop,gocyclo
 func setInt64(t target, v int64) error {
 	f := t.get()
 
 	switch f.Kind() {
 	case reflect.Int64:
-		return t.setInt64(v)
+		err := t.setInt64(v)
+		if err != nil {
+			return fmt.Errorf("setInt64: %w", err)
+		}
+
+		return nil
 	case reflect.Int32:
 		if v < math.MinInt32 || v > math.MaxInt32 {
-			return fmt.Errorf("integer %d does not fit in an int32", v)
+			return fmt.Errorf("setInt64: integer %d %w", v, errSetInt64InInt32)
 		}
-		return t.set(reflect.ValueOf(int32(v)))
+
+		err := t.set(reflect.ValueOf(int32(v)))
+		if err != nil {
+			return fmt.Errorf("setInt64: %w", err)
+		}
+
+		return nil
 	case reflect.Int16:
 		if v < math.MinInt16 || v > math.MaxInt16 {
-			return fmt.Errorf("integer %d does not fit in an int16", v)
+			return fmt.Errorf("setInt64: integer %d %w", v, errSetInt64InInt16)
 		}
-		return t.set(reflect.ValueOf(int16(v)))
+
+		err := t.set(reflect.ValueOf(int16(v)))
+		if err != nil {
+			return fmt.Errorf("setInt64: %w", err)
+		}
+
+		return nil
 	case reflect.Int8:
 		if v < math.MinInt8 || v > math.MaxInt8 {
-			return fmt.Errorf("integer %d does not fit in an int8", v)
+			return fmt.Errorf("setInt64: integer %d %w", v, errSetInt64InInt8)
 		}
-		return t.set(reflect.ValueOf(int8(v)))
+
+		err := t.set(reflect.ValueOf(int8(v)))
+		if err != nil {
+			return fmt.Errorf("setInt64: %w", err)
+		}
+
+		return nil
 	case reflect.Int:
 		if v < minInt || v > maxInt {
-			return fmt.Errorf("integer %d does not fit in an int", v)
+			return fmt.Errorf("setInt64: integer %d %w", v, errSetInt64InInt)
 		}
-		return t.set(reflect.ValueOf(int(v)))
 
+		err := t.set(reflect.ValueOf(int(v)))
+		if err != nil {
+			return fmt.Errorf("setInt64: %w", err)
+		}
+
+		return nil
 	case reflect.Uint64:
 		if v < 0 {
-			return fmt.Errorf("negative integer %d cannot be stored in an uint64", v)
+			return fmt.Errorf("setInt64: %d, %w", v, errSetInt64InUint64)
 		}
-		return t.set(reflect.ValueOf(uint64(v)))
+
+		err := t.set(reflect.ValueOf(uint64(v)))
+		if err != nil {
+			return fmt.Errorf("setInt64: %w", err)
+		}
+
+		return nil
 	case reflect.Uint32:
 		if v < 0 {
-			return fmt.Errorf("negative integer %d cannot be stored in an uint32", v)
+			return fmt.Errorf("setInt64: %d, %w", v, errSetInt64InUint32)
 		}
+
 		if v > math.MaxUint32 {
-			return fmt.Errorf("integer %d cannot be stored in an uint32", v)
+			return fmt.Errorf("setInt64: %d, %w", v, errSetInt64InUint32Max)
 		}
-		return t.set(reflect.ValueOf(uint32(v)))
+
+		err := t.set(reflect.ValueOf(uint32(v)))
+		if err != nil {
+			return fmt.Errorf("setInt64: %w", err)
+		}
+
+		return nil
 	case reflect.Uint16:
 		if v < 0 {
-			return fmt.Errorf("negative integer %d cannot be stored in an uint16", v)
+			return fmt.Errorf("setInt64: %d, %w", v, errSetInt64InUint16)
 		}
+
 		if v > math.MaxUint16 {
-			return fmt.Errorf("integer %d cannot be stored in an uint16", v)
+			return fmt.Errorf("setInt64: %d, %w", v, errSetInt64InUint16Max)
 		}
-		return t.set(reflect.ValueOf(uint16(v)))
+
+		err := t.set(reflect.ValueOf(uint16(v)))
+		if err != nil {
+			return fmt.Errorf("setInt64: %w", err)
+		}
+
+		return nil
 	case reflect.Uint8:
 		if v < 0 {
-			return fmt.Errorf("negative integer %d cannot be stored in an uint8", v)
+			return fmt.Errorf("setInt64: %d, %w", v, errSetInt64InUint8)
 		}
+
 		if v > math.MaxUint8 {
-			return fmt.Errorf("integer %d cannot be stored in an uint8", v)
+			return fmt.Errorf("setInt64: %d, %w", v, errSetInt64InUint8Max)
 		}
-		return t.set(reflect.ValueOf(uint8(v)))
+
+		err := t.set(reflect.ValueOf(uint8(v)))
+		if err != nil {
+			return fmt.Errorf("setInt64: %w", err)
+		}
+
+		return nil
 	case reflect.Uint:
 		if v < 0 {
-			return fmt.Errorf("negative integer %d cannot be stored in an uint", v)
+			return fmt.Errorf("setInt64: %d, %w", v, errSetInt64InUint)
 		}
-		return t.set(reflect.ValueOf(uint(v)))
+
+		err := t.set(reflect.ValueOf(uint(v)))
+		if err != nil {
+			return fmt.Errorf("setInt64: %w", err)
+		}
+
+		return nil
 	case reflect.Interface:
-		return t.set(reflect.ValueOf(v))
+		err := t.set(reflect.ValueOf(v))
+		if err != nil {
+			return fmt.Errorf("setInt64: %w", err)
+		}
+
+		return nil
 	default:
-		return fmt.Errorf("cannot assign int64 to a %s", f.String())
+		return fmt.Errorf("setInt64: %s, %w", f.String(), errSetInt64Unknown)
 	}
 }
 
+var (
+	errSetFloat64InFloat32Max = errors.New("does not fit in an float32")
+	errSetFloat64Unknown      = errors.New("does not fit in an float32")
+)
+
 func setFloat64(t target, v float64) error {
 	f := t.get()
 
 	switch f.Kind() {
 	case reflect.Float64:
-		return t.setFloat64(v)
+		err := t.setFloat64(v)
+		if err != nil {
+			return fmt.Errorf("setFloat64: %w", err)
+		}
+
+		return nil
 	case reflect.Float32:
 		if v > math.MaxFloat32 {
-			return fmt.Errorf("float %f cannot be stored in a float32", v)
+			return fmt.Errorf("setFloat64: %f %w", v, errSetFloat64InFloat32Max)
 		}
-		return t.set(reflect.ValueOf(float32(v)))
+
+		err := t.set(reflect.ValueOf(float32(v)))
+		if err != nil {
+			return fmt.Errorf("setFloat64: %w", err)
+		}
+
+		return nil
 	case reflect.Interface:
-		return t.set(reflect.ValueOf(v))
+		err := t.set(reflect.ValueOf(v))
+		if err != nil {
+			return fmt.Errorf("setFloat64: %w", err)
+		}
+
+		return nil
 	default:
-		return fmt.Errorf("cannot assign float64 to a %s", f.String())
+		return fmt.Errorf("setFloat64: %s %w", f.String(), errSetFloat64Unknown)
 	}
 }
 
+var (
+	errElementAtCannotOn        = errors.New("cannot elementAt")
+	errElementAtCannotOnUnknown = errors.New("cannot elementAt")
+)
+
+//nolint:cyclop
 // Returns the element at idx of the value pointed at by target, or an error if
 // t does not point to an indexable.
 // If the target points to an Array and idx is out of bounds, it returns
@@ -291,95 +489,111 @@ func elementAt(t target, idx int) (target, error) {
 
 	switch f.Kind() {
 	case reflect.Slice:
+		//nolint:godox
 		// TODO: use the idx function argument and avoid alloc if possible.
 		idx := f.Len()
+
 		err := t.set(reflect.Append(f, reflect.New(f.Type().Elem()).Elem()))
 		if err != nil {
-			return nil, err
+			return nil, fmt.Errorf("elementAt: %w", err)
 		}
+
 		return valueTarget(t.get().Index(idx)), nil
 	case reflect.Array:
 		if idx >= f.Len() {
 			return nil, nil
 		}
+
 		return valueTarget(f.Index(idx)), nil
 	case reflect.Interface:
 		if f.IsNil() {
 			panic("interface should have been initialized")
 		}
+
 		ifaceElem := f.Elem()
 		if ifaceElem.Kind() != reflect.Slice {
-			return nil, fmt.Errorf("cannot elementAt on a %s", f.Kind())
+			return nil, fmt.Errorf("elementAt: %w on a %s", errElementAtCannotOn, f.Kind())
 		}
+
 		idx := ifaceElem.Len()
 		newElem := reflect.New(ifaceElem.Type().Elem()).Elem()
 		newSlice := reflect.Append(ifaceElem, newElem)
+
 		err := t.set(newSlice)
 		if err != nil {
-			return nil, err
+			return nil, fmt.Errorf("elementAt: %w", err)
 		}
+
 		return valueTarget(t.get().Elem().Index(idx)), nil
 	case reflect.Ptr:
 		return elementAt(valueTarget(f.Elem()), idx)
 	default:
-		return nil, fmt.Errorf("cannot elementAt on a %s", f.Kind())
+		return nil, fmt.Errorf("elementAt: %w on a %s", errElementAtCannotOnUnknown, f.Kind())
 	}
 }
 
-func (d *decoder) scopeTableTarget(append bool, t target, name string) (target, bool, error) {
+//nolint:cyclop
+func (d *decoder) scopeTableTarget(shouldAppend bool, t target, name string) (target, bool, error) {
 	x := t.get()
 
 	switch x.Kind() {
 	// Kinds that need to recurse
-
 	case reflect.Interface:
-		t, err := scopeInterface(append, t)
+		t, err := scopeInterface(shouldAppend, t)
 		if err != nil {
-			return t, false, err
+			return t, false, fmt.Errorf("scopeTableTarget: %w", err)
 		}
-		return d.scopeTableTarget(append, t, name)
+
+		return d.scopeTableTarget(shouldAppend, t, name)
 	case reflect.Ptr:
 		t, err := scopePtr(t)
 		if err != nil {
-			return t, false, err
+			return t, false, fmt.Errorf("scopeTableTarget: %w", err)
 		}
-		return d.scopeTableTarget(append, t, name)
+
+		return d.scopeTableTarget(shouldAppend, t, name)
 	case reflect.Slice:
-		t, err := scopeSlice(append, t)
+		t, err := scopeSlice(shouldAppend, t)
 		if err != nil {
-			return t, false, err
+			return t, false, fmt.Errorf("scopeTableTarget: %w", err)
 		}
-		append = false
-		return d.scopeTableTarget(append, t, name)
+		shouldAppend = false
+
+		return d.scopeTableTarget(shouldAppend, t, name)
 	case reflect.Array:
-		t, err := d.scopeArray(append, t)
+		t, err := d.scopeArray(shouldAppend, t)
 		if err != nil {
-			return t, false, err
+			return t, false, fmt.Errorf("scopeTableTarget: %w", err)
 		}
-		append = false
-		return d.scopeTableTarget(append, t, name)
+		shouldAppend = false
+
+		return d.scopeTableTarget(shouldAppend, t, name)
 
 	// Terminal kinds
-
 	case reflect.Struct:
 		return scopeStruct(x, name)
 	case reflect.Map:
 		if x.IsNil() {
-			t.set(reflect.MakeMap(x.Type()))
+			err := t.set(reflect.MakeMap(x.Type()))
+			if err != nil {
+				return t, false, fmt.Errorf("scopeTableTarget: %w", err)
+			}
+
 			x = t.get()
 		}
 
 		return scopeMap(x, name)
 	default:
-		panic(fmt.Errorf("can't scope on a %s", x.Kind()))
+		panic(fmt.Sprintf("can't scope on a %s", x.Kind()))
 	}
 }
 
-func scopeInterface(append bool, t target) (target, error) {
-	err := initInterface(append, t)
+func scopeInterface(shouldAppend bool, t target) (target, error) {
+	err := initInterface(shouldAppend, t)
 	if err != nil {
 		return t, err
 	}
+
 	return interfaceTarget{t}, nil
 }
 
@@ -388,6 +602,7 @@ func scopePtr(t target) (target, error) {
 	if err != nil {
 		return t, err
 	}
+
 	return valueTarget(t.get().Elem()), nil
 }
 
@@ -396,13 +611,19 @@ func initPtr(t target) error {
 	if !x.IsNil() {
 		return nil
 	}
-	return t.set(reflect.New(x.Type().Elem()))
+
+	err := t.set(reflect.New(x.Type().Elem()))
+	if err != nil {
+		return fmt.Errorf("initPtr: %w", err)
+	}
+
+	return nil
 }
 
 // initInterface makes sure that the interface pointed at by the target is not
 // nil.
 // Returns the target to the initialized value of the target.
-func initInterface(append bool, t target) error {
+func initInterface(shouldAppend bool, t target) error {
 	x := t.get()
 
 	if x.Kind() != reflect.Interface {
@@ -414,54 +635,63 @@ func initInterface(append bool, t target) error {
 	}
 
 	var newElement reflect.Value
-	if append {
+	if shouldAppend {
 		newElement = reflect.MakeSlice(sliceInterfaceType, 0, 0)
 	} else {
 		newElement = reflect.MakeMap(mapStringInterfaceType)
 	}
+
 	err := t.set(newElement)
 	if err != nil {
-		return err
+		return fmt.Errorf("initInterface: %w", err)
 	}
 
 	return nil
 }
 
-func scopeSlice(append bool, t target) (target, error) {
+func scopeSlice(shouldAppend bool, t target) (target, error) {
 	v := t.get()
 
-	if append {
+	if shouldAppend {
 		newElem := reflect.New(v.Type().Elem())
 		newSlice := reflect.Append(v, newElem.Elem())
+
 		err := t.set(newSlice)
 		if err != nil {
-			return t, err
+			return t, fmt.Errorf("scopeSlice: %w", err)
 		}
+
 		v = t.get()
 	}
+
 	return valueTarget(v.Index(v.Len() - 1)), nil
 }
 
-func (d *decoder) scopeArray(append bool, t target) (target, error) {
+var errScopeArrayNotEnoughSpace = errors.New("not enough space in the array")
+
+func (d *decoder) scopeArray(shouldAppend bool, t target) (target, error) {
 	v := t.get()
 
-	idx := d.arrayIndex(append, v)
+	idx := d.arrayIndex(shouldAppend, v)
 
 	if idx >= v.Len() {
-		return nil, fmt.Errorf("not enough space in the array")
+		return nil, errScopeArrayNotEnoughSpace
 	}
 
 	return valueTarget(v.Index(idx)), nil
 }
 
+var errScopeMapCannotConvertStringToKey = errors.New("cannot convert string into map key type")
+
 func scopeMap(v reflect.Value, name string) (target, bool, error) {
 	k := reflect.ValueOf(name)
 
 	keyType := v.Type().Key()
 	if !k.Type().AssignableTo(keyType) {
 		if !k.Type().ConvertibleTo(keyType) {
-			return nil, false, fmt.Errorf("cannot convert string into map key type %s", keyType)
+			return nil, false, fmt.Errorf("scopeMap: %w %s", errScopeMapCannotConvertStringToKey, keyType)
 		}
+
 		k = k.Convert(keyType)
 	}
 
@@ -487,6 +717,7 @@ func (c *fieldPathsCache) get(t reflect.Type) (fieldPathsMap, bool) {
 	c.l.RLock()
 	paths, ok := c.m[t]
 	c.l.RUnlock()
+
 	return paths, ok
 }
 
@@ -502,13 +733,14 @@ var globalFieldPathsCache = fieldPathsCache{
 }
 
 func scopeStruct(v reflect.Value, name string) (target, bool, error) {
+	//nolint:godox
 	// TODO: cache this, and reduce allocations
-
 	fieldPaths, ok := globalFieldPathsCache.get(v.Type())
 	if !ok {
 		fieldPaths = map[string][]int{}
 
 		path := make([]int, 0, 16)
+
 		var walk func(reflect.Value)
 		walk = func(v reflect.Value) {
 			t := v.Type()
@@ -516,6 +748,7 @@ func scopeStruct(v reflect.Value, name string) (target, bool, error) {
 				l := len(path)
 				path = append(path, i)
 				f := t.Field(i)
+
 				if f.Anonymous {
 					walk(v.Field(i))
 				} else if f.PkgPath == "" {
@@ -545,6 +778,7 @@ func scopeStruct(v reflect.Value, name string) (target, bool, error) {
 	if !ok {
 		path, ok = fieldPaths[strings.ToLower(name)]
 	}
+
 	if !ok {
 		return nil, false, nil
 	}