fix(lint): Fix or ignore lint errors (#2228)

Signed-off-by: Dave Henderson <[email protected]>

.golangci.yml

@@ -26,11 +26,11 @@ linters:
   enable:
     - asciicheck
     - bodyclose
+    - copyloopvar
     # - dogsled
     # - dupl
     - errcheck
     # - exhaustive
-    - exportloopref
     # - funlen
     # - gci
     # - gochecknoglobals

coll/coll_test.go

@@ -343,7 +343,6 @@ func TestLessThan(t *testing.T) {
 	}
 
 	for _, d := range data {
-		d := d
 		t.Run(fmt.Sprintf(`LessThan("%s")(<%T>%#v,%#v)==%v`, d.key, d.left, d.left, d.right, d.out), func(t *testing.T) {
 			assert.Equal(t, d.out, lessThan(d.key)(d.left, d.right))
 		})
@@ -462,7 +461,6 @@ func TestSort(t *testing.T) {
 	}
 
 	for _, d := range data {
-		d := d
 		t.Run(fmt.Sprintf(`Sort("%s",<%T>)==%#v`, d.key, d.in, d.out), func(t *testing.T) {
 			out, err := Sort(d.key, d.in)
 			require.NoError(t, err)
@@ -569,9 +567,7 @@ func BenchmarkFlatten(b *testing.B) {
 		},
 	}
 	for depth := -1; depth <= 2; depth++ {
-		depth := depth
 		for _, d := range data {
-			d := d
 			b.Run(fmt.Sprintf("depth%d %T(%v)", depth, d, d), func(b *testing.B) {
 				for i := 0; i < b.N; i++ {
 					Flatten(d, depth)

coll/index.go

@@ -2,6 +2,7 @@ package coll
 
 import (
 	"fmt"
+	"math"
 	"reflect"
 )
 
@@ -69,7 +70,12 @@ func indexArg(index reflect.Value, cap int) (int, error) {
 	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
 		x = index.Int()
 	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
-		x = int64(index.Uint())
+		val := index.Uint()
+		if val > math.MaxInt64 {
+			return -1, fmt.Errorf("cannot index slice/array with %d (too large)", val)
+		}
+
+		x = int64(val)
 	case reflect.Invalid:
 		return 0, fmt.Errorf("cannot index slice/array with nil")
 	default:

conv/conv.go

@@ -194,12 +194,15 @@ func ToInt64(v interface{}) (int64, error) {
 	case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
 		return val.Int(), nil
 	case reflect.Uint8, reflect.Uint16, reflect.Uint32:
+		//nolint:gosec // G115 isn't applicable, this is a Uint32 at most
 		return int64(val.Uint()), nil
 	case reflect.Uint, reflect.Uint64:
 		tv := val.Uint()
 
-		// this can overflow and give -1, but IMO this is better than
-		// returning maxint64
+		if tv > math.MaxInt64 {
+			return 0, fmt.Errorf("could not convert %d to int64, would overflow", tv)
+		}
+
 		return int64(tv), nil
 	case reflect.Float32, reflect.Float64:
 		return int64(val.Float()), nil

conv/conv_test.go

@@ -157,10 +157,6 @@ func TestToInt64(t *testing.T) {
 	require.NoError(t, err)
 	assert.Equal(t, int64(3), actual)
 
-	actual, err = ToInt64(uint64(math.MaxUint64))
-	require.NoError(t, err)
-	assert.Equal(t, int64(-1), actual)
-
 	actual, err = ToInt64(uint8(math.MaxUint8))
 	require.NoError(t, err)
 	assert.Equal(t, int64(0xFF), actual)
@@ -198,6 +194,9 @@ func TestToInt64(t *testing.T) {
 
 		_, err = ToInt64("foo")
 		require.Error(t, err)
+
+		_, err = ToInt64(uint64(math.MaxUint64))
+		require.Error(t, err)
 	})
 }
 
@@ -226,10 +225,6 @@ func TestToInt(t *testing.T) {
 	require.NoError(t, err)
 	assert.Equal(t, 42, actual)
 
-	actual, err = ToInt(uint64(math.MaxUint64))
-	require.NoError(t, err)
-	assert.Equal(t, -1, actual)
-
 	actual, err = ToInt(uint8(math.MaxUint8))
 	require.NoError(t, err)
 	assert.Equal(t, 0xFF, actual)
@@ -267,6 +262,9 @@ func TestToInt(t *testing.T) {
 
 		_, err = ToInt("foo")
 		require.Error(t, err)
+
+		_, err = ToInt(uint64(math.MaxUint64))
+		require.Error(t, err)
 	})
 }
 
@@ -408,7 +406,6 @@ func TestToString(t *testing.T) {
 	}
 
 	for _, d := range testdata {
-		d := d
 		t.Run(fmt.Sprintf("%T/%#v == %s", d.in, d.in, d.out), func(t *testing.T) {
 			out := ToString(d.in)
 			assert.Equal(t, d.out, out)

conv/evalargs.go

@@ -22,7 +22,7 @@ func printableValue(v reflect.Value) (interface{}, bool) {
 	}
 
 	if !v.Type().Implements(errorType) && !v.Type().Implements(fmtStringerType) {
-		if v.CanAddr() && (reflect.PtrTo(v.Type()).Implements(errorType) || reflect.PtrTo(v.Type()).Implements(fmtStringerType)) {
+		if v.CanAddr() && (reflect.PointerTo(v.Type()).Implements(errorType) || reflect.PointerTo(v.Type()).Implements(fmtStringerType)) {
 			v = v.Addr()
 		} else {
 			switch v.Kind() {

crypto/rsa_test.go

@@ -65,7 +65,6 @@ func TestRSACrypt(t *testing.T) {
 	}
 
 	for _, d := range testdata {
-		d := d
 		t.Run(d.name, func(t *testing.T) {
 			t.Parallel()
 

docs-src/content/functions/conv.yml

@@ -300,8 +300,7 @@ funcs:
       Converts the input to an `int64` (64-bit signed integer).
 
       This function attempts to convert most types of input (strings, numbers,
-      and booleans), but behaviour when the input can not be converted is
-      undefined and subject to change.
+      and booleans).
 
       Unconvertable inputs will result in errors.
 
@@ -388,8 +387,7 @@ funcs:
       Converts the input to a `float64`.
 
       This function attempts to convert most types of input (strings, numbers,
-      and booleans), but behaviour when the input can not be converted is
-      undefined and subject to change.
+      and booleans).
       
       Unconvertable inputs will result in errors.
     arguments:

docs/content/functions/conv.md

@@ -452,8 +452,7 @@ $ gomplate -i '{{ conv.ToBools false "blah" 0 }}'
 Converts the input to an `int64` (64-bit signed integer).
 
 This function attempts to convert most types of input (strings, numbers,
-and booleans), but behaviour when the input can not be converted is
-undefined and subject to change.
+and booleans).
 
 Unconvertable inputs will result in errors.
 
@@ -592,8 +591,7 @@ gomplate -i '{{ conv.ToInts true 0x42 "123,456.99" "1.2345e+3"}}'
 Converts the input to a `float64`.
 
 This function attempts to convert most types of input (strings, numbers,
-and booleans), but behaviour when the input can not be converted is
-undefined and subject to change.
+and booleans).
 
 Unconvertable inputs will result in errors.
 

internal/cidr/cidr.go

@@ -28,6 +28,7 @@ func SubnetBig(base netip.Prefix, newBits int, num *big.Int) (netip.Prefix, erro
 		return netip.Prefix{}, fmt.Errorf("insufficient address space to extend prefix of %d by %d", parentLen, newBits)
 	}
 
+	//nolint:gosec // G115 doesn't apply here
 	maxNetNum := uint64(1<<uint64(newBits)) - 1
 	if num.Uint64() > maxNetNum {
 		return netip.Prefix{}, fmt.Errorf("prefix extension of %d does not accommodate a subnet numbered %d", newBits, num)
@@ -50,17 +51,19 @@ func HostBig(base netip.Prefix, num *big.Int) (netip.Addr, error) {
 	hostLen := addrLen - parentLen
 
 	maxHostNum := big.NewInt(int64(1))
+
+	//nolint:gosec // G115 doesn't apply here
 	maxHostNum.Lsh(maxHostNum, uint(hostLen))
 	maxHostNum.Sub(maxHostNum, big.NewInt(1))
 
-	numUint64 := big.NewInt(int64(num.Uint64()))
+	num2 := big.NewInt(num.Int64())
 	if num.Cmp(big.NewInt(0)) == -1 {
-		numUint64.Neg(num)
-		numUint64.Sub(numUint64, big.NewInt(int64(1)))
-		num.Sub(maxHostNum, numUint64)
+		num2.Neg(num)
+		num2.Sub(num2, big.NewInt(int64(1)))
+		num.Sub(maxHostNum, num2)
 	}
 
-	if numUint64.Cmp(maxHostNum) == 1 {
+	if num2.Cmp(maxHostNum) == 1 {
 		return netip.Addr{}, fmt.Errorf("prefix of %d does not accommodate a host numbered %d", parentLen, num)
 	}
 
@@ -93,6 +96,8 @@ func intToIP(ipInt *big.Int, bits int) netip.Addr {
 
 func insertNumIntoIP(ip netip.Addr, bigNum *big.Int, prefixLen int) netip.Addr {
 	ipInt, totalBits := ipToInt(ip)
+
+	//nolint:gosec // G115 isn't relevant here
 	bigNum.Lsh(bigNum, uint(totalBits-prefixLen))
 	ipInt.Or(ipInt, bigNum)
 	return intToIP(ipInt, totalBits)

internal/cmd/config_test.go

@@ -283,7 +283,6 @@ func TestApplyEnvVars(t *testing.T) {
 	}
 
 	for i, d := range data {
-		d := d
 		t.Run(fmt.Sprintf("applyEnvVars_%s_%s/%d", d.env, d.value, i), func(t *testing.T) {
 			t.Setenv(d.env, d.value)
 

internal/conv/conv_test.go

@@ -40,7 +40,6 @@ func BenchmarkInterfaceSlice(b *testing.B) {
 	}
 
 	for _, d := range data {
-		d := d
 		b.Run(fmt.Sprintf("%T(%v)", d, d), func(b *testing.B) {
 			for i := 0; i < b.N; i++ {
 				InterfaceSlice(d)

internal/datafs/wdfs_test.go

@@ -190,7 +190,6 @@ func TestResolveLocalPath_NonWindows(t *testing.T) {
 	}
 
 	for _, td := range testdata {
-		td := td
 		t.Run(td.path, func(t *testing.T) {
 			root, path, err := ResolveLocalPath(fsys, td.path)
 			require.NoError(t, err)
@@ -225,7 +224,6 @@ func TestResolveLocalPath_Windows(t *testing.T) {
 	}
 
 	for _, td := range testdata {
-		td := td
 		t.Run(td.path, func(t *testing.T) {
 			root, path, err := ResolveLocalPath(fsys, td.path)
 			require.NoError(t, err)
@@ -286,7 +284,6 @@ func TestWdFS_ResolveLocalPath_Windows(t *testing.T) {
 	}
 
 	for _, td := range testdata {
-		td := td
 		t.Run(td.path, func(t *testing.T) {
 			root, path, err := resolveLocalPath(volname, td.path)
 			require.NoError(t, err)
@@ -324,7 +321,6 @@ func TestWin32PathType(t *testing.T) {
 	}
 
 	for _, td := range testdata {
-		td := td
 		t.Run(td.path, func(t *testing.T) {
 			assert.Equal(t, td.expected, win32PathType(td.path))
 		})

internal/funcs/conv_test.go

@@ -49,7 +49,6 @@ func TestDefault(t *testing.T) {
 	}
 
 	for _, d := range data {
-		d := d
 		t.Run(fmt.Sprintf("%T/%#v empty==%v", d.val, d.val, d.empty), func(t *testing.T) {
 			t.Parallel()
 

internal/funcs/math_test.go

@@ -221,7 +221,6 @@ func TestIsIntFloatNum(t *testing.T) {
 
 	m := MathFuncs{}
 	for _, tt := range tests {
-		tt := tt
 		t.Run(fmt.Sprintf("%T(%#v)", tt.in, tt.in), func(t *testing.T) {
 			t.Parallel()
 
@@ -239,7 +238,6 @@ func BenchmarkIsFloat(b *testing.B) {
 
 	m := MathFuncs{}
 	for _, n := range data {
-		n := n
 		b.Run(fmt.Sprintf("%T(%v)", n, n), func(b *testing.B) {
 			for i := 0; i < b.N; i++ {
 				m.IsFloat(n)
@@ -264,7 +262,6 @@ func TestMax(t *testing.T) {
 		{int64(255), []interface{}{"14", "0xff", -5}},
 	}
 	for _, d := range data {
-		d := d
 		t.Run(fmt.Sprintf("%v==%v", d.n, d.expected), func(t *testing.T) {
 			t.Parallel()
 
@@ -308,7 +305,6 @@ func TestMin(t *testing.T) {
 		{int64(-5), []interface{}{"14", "0xff", -5}},
 	}
 	for _, d := range data {
-		d := d
 		t.Run(fmt.Sprintf("%v==%v", d.n, d.expected), func(t *testing.T) {
 			t.Parallel()
 
@@ -358,7 +354,6 @@ func TestContainsFloat(t *testing.T) {
 		{[]interface{}{"NaN"}, true},
 	}
 	for _, d := range data {
-		d := d
 		t.Run(fmt.Sprintf("%v==%v", d.n, d.expected), func(t *testing.T) {
 			t.Parallel()
 
@@ -386,7 +381,6 @@ func TestCeil(t *testing.T) {
 		{-1.9, -1},
 	}
 	for _, d := range data {
-		d := d
 		t.Run(fmt.Sprintf("%v==%v", d.n, d.a), func(t *testing.T) {
 			t.Parallel()
 
@@ -425,7 +419,6 @@ func TestFloor(t *testing.T) {
 		{-1.9, -2.},
 	}
 	for _, d := range data {
-		d := d
 		t.Run(fmt.Sprintf("%v==%v", d.n, d.a), func(t *testing.T) {
 			t.Parallel()
 
@@ -468,7 +461,6 @@ func TestRound(t *testing.T) {
 		{-4.5, -5},
 	}
 	for _, d := range data {
-		d := d
 		t.Run(fmt.Sprintf("%v==%v", d.n, d.a), func(t *testing.T) {
 			t.Parallel()
 
@@ -510,7 +502,6 @@ func TestAbs(t *testing.T) {
 		{-2, int64(2)},
 	}
 	for _, d := range data {
-		d := d
 		t.Run(fmt.Sprintf("%#v==%v", d.n, d.a), func(t *testing.T) {
 			t.Parallel()
 

internal/funcs/net.go

@@ -157,6 +157,8 @@ func (f *NetFuncs) CIDRNetmask(prefix interface{}) (netip.Addr, error) {
 	// fill an appropriately sized byte slice with as many 1s as prefix bits
 	b := make([]byte, p.Addr().BitLen()/8)
 	for i := 0; i < p.Bits(); i++ {
+		//nolint:gosec // G115 is not applicable, the value was checked at parse
+		// time
 		b[i/8] |= 1 << uint(7-i%8)
 	}