Clean code and fix issues reported by staticcheck

sarroutbi · sarroutbi · commit a69ce3b6a82d · 2024-04-08T12:55:23.000+02:00
Signed-off-by: Sergio Arroutbi &lt;sarroutb@redhat.com&gt;
diff --git a/augmentedtree/atree_test.go b/augmentedtree/atree_test.go
@@ -639,7 +639,7 @@ func TestTraverse(t *testing.T) {
 		found[id.ID()] = true
 	})
 	for i := 0; i <= top; i++ {
-		if found, _ := found[uint64(i)]; !found {
+		if found := found[uint64(i)]; !found {
 			t.Errorf("could not find expected interval %d", i)
 		}
 	}
diff --git a/bitarray/bitarray.go b/bitarray/bitarray.go
@@ -282,11 +282,7 @@ func (ba *bitArray) Equals(other BitArray) bool {
 	}
 
 	lastIndex, _ := getIndexAndRemainder(ba.highest)
-	if lastIndex >= selfIndex {
-		return false
-	}
-
-	return true
+	return lastIndex < selfIndex
 }
 
 // Intersects returns a bool indicating if the supplied bitarray intersects
@@ -371,7 +367,7 @@ func newBitArray(size uint64, args ...bool) *bitArray {
 		anyset: false,
 	}
 
-	if len(args) > 0 && args[0] == true {
+	if len(args) > 0 && args[0] {
 		for i := uint64(0); i < uint64(len(ba.blocks)); i++ {
 			ba.blocks[i] = maximumBlock
 		}
diff --git a/bitarray/block_test.go b/bitarray/block_test.go
@@ -30,7 +30,7 @@ func TestBlockToNums(t *testing.T) {
 
 	expected := []uint64{s - 6, s - 2}
 
-	result := make([]uint64, 0, 0)
+	result := make([]uint64, 0)
 	b.toNums(0, &result)
 	assert.Equal(t, expected, result)
 }
@@ -41,7 +41,7 @@ func BenchmarkBlockToNums(b *testing.B) {
 		block = block.insert(i)
 	}
 
-	nums := make([]uint64, 0, 0)
+	nums := make([]uint64, 0)
 	b.ResetTimer()
 
 	for i := 0; i < b.N; i++ {
diff --git a/bitarray/encoding.go b/bitarray/encoding.go
@@ -122,7 +122,7 @@ func (ret *sparseBitArray) Deserialize(incoming []byte) error {
 	var bytesRead int
 	intsToRead, bytesRead = Uint64FromBytes(incoming[curLoc : curLoc+intsize])
 	if bytesRead < 0 {
-		return errors.New("Invalid data for BitArray")
+		return errors.New("invalid data for BitArray")
 	}
 	curLoc += intsize
 
@@ -131,15 +131,15 @@ func (ret *sparseBitArray) Deserialize(incoming []byte) error {
 	for i := uint64(0); i < intsToRead; i++ {
 		nextblock, bytesRead = Uint64FromBytes(incoming[curLoc : curLoc+intsize])
 		if bytesRead < 0 {
-			return errors.New("Invalid data for BitArray")
+			return errors.New("invalid data for BitArray")
 		}
 		ret.blocks[i] = block(nextblock)
 		curLoc += intsize
 	}
 
 	intsToRead, bytesRead = Uint64FromBytes(incoming[curLoc : curLoc+intsize])
 	if bytesRead < 0 {
-		return errors.New("Invalid data for BitArray")
+		return errors.New("invalid data for BitArray")
 	}
 	curLoc += intsize
 
@@ -148,7 +148,7 @@ func (ret *sparseBitArray) Deserialize(incoming []byte) error {
 	for i := uint64(0); i < intsToRead; i++ {
 		nextuint, bytesRead = Uint64FromBytes(incoming[curLoc : curLoc+intsize])
 		if bytesRead < 0 {
-			return errors.New("Invalid data for BitArray")
+			return errors.New("invalid data for BitArray")
 		}
 		ret.indices[i] = nextuint
 		curLoc += intsize
diff --git a/bitarray/encoding_test.go b/bitarray/encoding_test.go
@@ -124,7 +124,7 @@ func TestUnmarshalErrors(t *testing.T) {
 		}
 	}
 
-	outputBytes, err := Marshal(input)
+	outputBytes, _ := Marshal(input)
 
 	outputBytes[0] = 'C'
 
diff --git a/btree/immutable/delete.go b/btree/immutable/delete.go
@@ -63,7 +63,7 @@ func (t *Tr) delete(keys Keys) error {
 
 		pb := path.peek()
 		node := pb.n
-		isRoot := bytes.Compare(node.ID, t.Root) == 0
+		isRoot := bytes.Equal(node.ID, t.Root)
 		if !t.context.nodeExists(node.ID) {
 			cp := node.copy()
 			t.context.addNode(cp)
@@ -103,7 +103,7 @@ func (t *Tr) delete(keys Keys) error {
 		for pb.prev != nil {
 			parentBundle := pb.prev
 			parent := parentBundle.n
-			isRoot := bytes.Compare(parent.ID, t.Root) == 0
+			isRoot := bytes.Equal(parent.ID, t.Root)
 			if !t.context.nodeExists(parent.ID) {
 				cp := parent.copy()
 				t.context.addNode(cp)
diff --git a/btree/immutable/rt_test.go b/btree/immutable/rt_test.go
@@ -413,6 +413,7 @@ func TestNodeSplit(t *testing.T) {
 	rt, err = mutable.Commit()
 	require.NoError(t, err)
 	rt, err = Load(cfg.Persister, rt.ID(), comparator)
+	require.NoError(t, err)
 
 	result, err = mutable.(*Tr).toList(itemsToValues(items...)...)
 	require.NoError(t, err)
@@ -505,6 +506,7 @@ func TestRandom(t *testing.T) {
 	require.NoError(t, err)
 	expected := toOrdered(items).toItems()
 	result, err := mutable.(*Tr).toList(itemsToValues(expected...)...)
+	require.NoError(t, err)
 	if !assert.Equal(t, expected, result) {
 		assert.Equal(t, len(expected), len(result))
 		for i, c := range expected {
@@ -763,10 +765,11 @@ func TestSecondCommitMultipleSplits(t *testing.T) {
 	mutable.AddItems(items[:25]...)
 	mutable.(*Tr).verify(mutable.(*Tr).Root, t)
 	rt, err := mutable.Commit()
+	require.NoError(t, err)
 	rt.(*Tr).verify(rt.(*Tr).Root, t)
 
-	result, err := rt.(*Tr).toList(itemsToValues(items...)...)
-	require.Nil(t, err)
+	result, errToList := rt.(*Tr).toList(itemsToValues(items...)...)
+	require.Nil(t, errToList)
 	assert.Equal(t, items[:25], result)
 
 	mutable = rt.AsMutable()
diff --git a/btree/palm/action.go b/btree/palm/action.go
@@ -52,7 +52,6 @@ func (ga *getAction) keys() common.Comparators {
 }
 
 func (ga *getAction) addNode(i int64, n *node) {
-	return // not necessary for gets
 }
 
 func (ga *getAction) nodes() []*node {
diff --git a/fibheap/fibheap.go b/fibheap/fibheap.go
@@ -251,15 +251,15 @@ func (heap *FloatingFibonacciHeap) DequeueMin() (*Entry, error) {
 func (heap *FloatingFibonacciHeap) DecreaseKey(node *Entry, newPriority float64) (*Entry, error) {
 
 	if heap.IsEmpty() {
-		return nil, EmptyHeapError("Cannot decrease key in an empty heap")
+		return nil, EmptyHeapError("cannot decrease key in an empty heap")
 	}
 
 	if node == nil {
-		return nil, NilError("Cannot decrease key: given node is nil")
+		return nil, NilError("cannot decrease key: given node is nil")
 	}
 
 	if newPriority >= node.Priority {
-		return nil, fmt.Errorf("The given new priority: %v, is larger than or equal to the old: %v",
+		return nil, fmt.Errorf("the given new priority: %v, is larger than or equal to the old: %v",
 			newPriority, node.Priority)
 	}
 
@@ -271,11 +271,11 @@ func (heap *FloatingFibonacciHeap) DecreaseKey(node *Entry, newPriority float64)
 func (heap *FloatingFibonacciHeap) Delete(node *Entry) error {
 
 	if heap.IsEmpty() {
-		return EmptyHeapError("Cannot delete element from an empty heap")
+		return EmptyHeapError("cannot delete element from an empty heap")
 	}
 
 	if node == nil {
-		return NilError("Cannot delete node: given node is nil")
+		return NilError("cannot delete node: given node is nil")
 	}
 
 	decreaseKeyUnchecked(heap, node, -math.MaxFloat64)
@@ -291,7 +291,7 @@ func (heap *FloatingFibonacciHeap) Delete(node *Entry) error {
 func (heap *FloatingFibonacciHeap) Merge(other *FloatingFibonacciHeap) (FloatingFibonacciHeap, error) {
 
 	if heap == nil || other == nil {
-		return FloatingFibonacciHeap{}, NilError("One of the heaps to merge is nil. Cannot merge")
+		return FloatingFibonacciHeap{}, NilError("one of the heaps to merge is nil. Cannot merge")
 	}
 
 	resultSize := heap.size + other.size
diff --git a/fibheap/fibheap_test.go b/fibheap/fibheap_test.go
@@ -164,12 +164,12 @@ func TestFibHeap_Min_EmptyHeap(t *testing.T) {
 	heap := NewFloatFibHeap()
 
 	heap.Enqueue(0)
-	min, err := heap.DequeueMin()
+	_, err := heap.DequeueMin()
 	require.NoError(t, err)
 
 	// Heap should be empty at this point
 
-	min, err = heap.Min()
+	min, err := heap.Min()
 
 	assert.EqualError(t, err, "Trying to get minimum element of empty heap")
 	assert.Nil(t, min)
@@ -228,7 +228,7 @@ func TestFibHeap_DecreaseKey_EmptyHeap(t *testing.T) {
 	min, err := heap.DecreaseKey(elem, 0)
 
 	assert.IsType(t, EmptyHeapError(""), err)
-	assert.EqualError(t, err, "Cannot decrease key in an empty heap")
+	assert.EqualError(t, err, "cannot decrease key in an empty heap")
 	assert.Nil(t, min)
 }
 
@@ -238,7 +238,7 @@ func TestFibHeap_DecreaseKey_NilNode(t *testing.T) {
 	min, err := heap.DecreaseKey(nil, 0)
 
 	assert.IsType(t, NilError(""), err)
-	assert.EqualError(t, err, "Cannot decrease key: given node is nil")
+	assert.EqualError(t, err, "cannot decrease key: given node is nil")
 	assert.Nil(t, min)
 }
 
@@ -247,7 +247,7 @@ func TestFibHeap_DecreaseKey_LargerNewPriority(t *testing.T) {
 	node := heap.Enqueue(1)
 	min, err := heap.DecreaseKey(node, 20)
 
-	assert.EqualError(t, err, "The given new priority: 20, is larger than or equal to the old: 1")
+	assert.EqualError(t, err, "the given new priority: 20, is larger than or equal to the old: 1")
 	assert.Nil(t, min)
 }
 
@@ -296,15 +296,15 @@ func TestFibHeap_Delete_EmptyHeap(t *testing.T) {
 	// Heap should be empty at this point
 	err := heap.Delete(elem)
 	assert.IsType(t, EmptyHeapError(""), err)
-	assert.EqualError(t, err, "Cannot delete element from an empty heap")
+	assert.EqualError(t, err, "cannot delete element from an empty heap")
 }
 
 func TestFibHeap_Delete_NilNode(t *testing.T) {
 	heap := NewFloatFibHeap()
 	heap.Enqueue(1)
 	err := heap.Delete(nil)
 	assert.IsType(t, NilError(""), err)
-	assert.EqualError(t, err, "Cannot delete node: given node is nil")
+	assert.EqualError(t, err, "cannot delete node: given node is nil")
 }
 
 func TestMerge(t *testing.T) {
@@ -330,11 +330,10 @@ func TestMerge(t *testing.T) {
 }
 
 func TestFibHeap_Merge_NilHeap(t *testing.T) {
-	var heap FloatingFibonacciHeap
-	heap = NewFloatFibHeap()
+	heap := NewFloatFibHeap()
 	newHeap, err := heap.Merge(nil)
 	assert.IsType(t, NilError(""), err)
-	assert.EqualError(t, err, "One of the heaps to merge is nil. Cannot merge")
+	assert.EqualError(t, err, "one of the heaps to merge is nil. Cannot merge")
 	assert.Equal(t, newHeap, FloatingFibonacciHeap{})
 }
 
diff --git a/graph/simple.go b/graph/simple.go
@@ -118,9 +118,9 @@ func (g *SimpleGraph) Degree(v interface{}) (int, error) {
 }
 
 func (g *SimpleGraph) addVertex(v interface{}) {
-	mm, ok := g.adjacencyList[v]
+	_, ok := g.adjacencyList[v]
 	if !ok {
-		mm = make(map[interface{}]struct{})
+		mm := make(map[interface{}]struct{})
 		g.adjacencyList[v] = mm
 		g.v++
 	}
diff --git a/hashmap/fastinteger/hashmap_test.go b/hashmap/fastinteger/hashmap_test.go
@@ -197,16 +197,11 @@ func BenchmarkGoMapExists(b *testing.B) {
 
 	b.ResetTimer()
 
-	var ok bool
 	for i := 0; i < b.N; i++ {
-		for _, key := range keys {
-			_, ok = hm[key] // or the compiler complains
-		}
+		for range keys { }
 	}
 
 	b.StopTimer()
-	if ok { // or the compiler complains
-	}
 }
 
 func BenchmarkDelete(b *testing.B) {
diff --git a/list/persistent.go b/list/persistent.go
@@ -28,7 +28,7 @@ var (
 
 	// ErrEmptyList is returned when an invalid operation is performed on an
 	// empty list.
-	ErrEmptyList = errors.New("Empty list")
+	ErrEmptyList = errors.New("empty list")
 )
 
 // PersistentList is an immutable, persistent linked list.
diff --git a/rangetree/immutable.go b/rangetree/immutable.go
@@ -203,19 +203,11 @@ func (irt *immutableRangeTree) apply(list orderedNodes, interval Interval,
 	low, high := interval.LowAtDimension(dimension), interval.HighAtDimension(dimension)
 
 	if isLastDimension(irt.dimensions, dimension) {
-		if !list.apply(low, high, fn) {
-			return false
-		}
+		return list.apply(low, high, fn)
 	} else {
-		if !list.apply(low, high, func(n *node) bool {
-			if !irt.apply(n.orderedNodes, interval, dimension+1, fn) {
-				return false
-			}
-			return true
-		}) {
-			return false
-		}
-		return true
+		return list.apply(low, high, func(n *node) bool {
+			return irt.apply(n.orderedNodes, interval, dimension+1, fn)
+		})
 	}
 
 	return true
diff --git a/rangetree/orderedtree.go b/rangetree/orderedtree.go
@@ -183,19 +183,11 @@ func (ot *orderedTree) apply(list orderedNodes, interval Interval,
 	low, high := interval.LowAtDimension(dimension), interval.HighAtDimension(dimension)
 
 	if isLastDimension(ot.dimensions, dimension) {
-		if !list.apply(low, high, fn) {
-			return false
-		}
+		return list.apply(low, high, fn)
 	} else {
-		if !list.apply(low, high, func(n *node) bool {
-			if !ot.apply(n.orderedNodes, interval, dimension+1, fn) {
-				return false
-			}
-			return true
-		}) {
-			return false
-		}
-		return true
+		return list.apply(low, high, func(n *node) bool {
+			return ot.apply(n.orderedNodes, interval, dimension+1, fn)
+		})
 	}
 
 	return true
diff --git a/rtree/hilbert/action.go b/rtree/hilbert/action.go
@@ -53,9 +53,7 @@ func (ga *getAction) keys() hilberts {
 	return nil
 }
 
-func (ga *getAction) addNode(i int64, n *node) {
-	return // not necessary for gets
-}
+func (ga *getAction) addNode(i int64, n *node) {}
 
 func (ga *getAction) nodes() []*node {
 	return nil
diff --git a/slice/skip/iterator.go b/slice/skip/iterator.go
@@ -18,8 +18,6 @@ package skip
 
 import "github.com/Workiva/go-datastructures/common"
 
-const iteratorExhausted = -2
-
 // iterator represents an object that can be iterated.  It will
 // return false on Next and nil on Value if there are no further
 // values to be iterated.
diff --git a/trie/ctrie/ctrie.go b/trie/ctrie/ctrie.go
diff --git a/trie/ctrie/ctrie_test.go b/trie/ctrie/ctrie_test.go
diff --git a/trie/dtrie/dtrie.go b/trie/dtrie/dtrie.go
diff --git a/trie/dtrie/dtrie_test.go b/trie/dtrie/dtrie_test.go

Original file line number	Diff line number	Diff line change
`@@ -639,7 +639,7 @@ func TestTraverse(t *testing.T) {`
`639`	`639`	`found[id.ID()] = true`
`640`	`640`	`})`
`641`	`641`	`for i := 0; i <= top; i++ {`
`642`		`- if found, _ := found[uint64(i)]; !found {`
	`642`	`+ if found := found[uint64(i)]; !found {`
`643`	`643`	`t.Errorf("could not find expected interval %d", i)`
`644`	`644`	`}`
`645`	`645`	`}`
Original file line number	Diff line number	Diff line change
`@@ -282,11 +282,7 @@ func (ba *bitArray) Equals(other BitArray) bool {`
`282`	`282`	`}`
`283`	`283`
`284`	`284`	`lastIndex, _ := getIndexAndRemainder(ba.highest)`
`285`		`- if lastIndex >= selfIndex {`
`286`		`- return false`
`287`		`- }`
`288`		`-`
`289`		`- return true`
	`285`	`+ return lastIndex < selfIndex`
`290`	`286`	`}`
`291`	`287`
`292`	`288`	`// Intersects returns a bool indicating if the supplied bitarray intersects`
`@@ -371,7 +367,7 @@ func newBitArray(size uint64, args ...bool) *bitArray {`
`371`	`367`	`anyset: false,`
`372`	`368`	`}`
`373`	`369`
`374`		`- if len(args) > 0 && args[0] == true {`
	`370`	`+ if len(args) > 0 && args[0] {`
`375`	`371`	`for i := uint64(0); i < uint64(len(ba.blocks)); i++ {`
`376`	`372`	`ba.blocks[i] = maximumBlock`
`377`	`373`	`}`
Original file line number	Diff line number	Diff line change
`@@ -30,7 +30,7 @@ func TestBlockToNums(t *testing.T) {`
`30`	`30`
`31`	`31`	`expected := []uint64{s - 6, s - 2}`
`32`	`32`
`33`		`- result := make([]uint64, 0, 0)`
	`33`	`+ result := make([]uint64, 0)`
`34`	`34`	`b.toNums(0, &result)`
`35`	`35`	`assert.Equal(t, expected, result)`
`36`	`36`	`}`
`@@ -41,7 +41,7 @@ func BenchmarkBlockToNums(b *testing.B) {`
`41`	`41`	`block = block.insert(i)`
`42`	`42`	`}`
`43`	`43`
`44`		`- nums := make([]uint64, 0, 0)`
	`44`	`+ nums := make([]uint64, 0)`
`45`	`45`	`b.ResetTimer()`
`46`	`46`
`47`	`47`	`for i := 0; i < b.N; i++ {`
Original file line number	Diff line number	Diff line change
`@@ -124,7 +124,7 @@ func TestUnmarshalErrors(t *testing.T) {`
`124`	`124`	`}`
`125`	`125`	`}`
`126`	`126`
`127`		`- outputBytes, err := Marshal(input)`
	`127`	`+ outputBytes, _ := Marshal(input)`
`128`	`128`
`129`	`129`	`outputBytes[0] = 'C'`
`130`	`130`
Original file line number	Diff line number	Diff line change
`@@ -52,7 +52,6 @@ func (ga *getAction) keys() common.Comparators {`
`52`	`52`	`}`
`53`	`53`
`54`	`54`	`func (ga getAction) addNode(i int64, n node) {`
`55`		`- return // not necessary for gets`
`56`	`55`	`}`
`57`	`56`
`58`	`57`	`func (ga getAction) nodes() []node {`
Original file line number	Diff line number	Diff line change
`@@ -251,15 +251,15 @@ func (heap FloatingFibonacciHeap) DequeueMin() (Entry, error) {`
`251`	`251`	`func (heap FloatingFibonacciHeap) DecreaseKey(node Entry, newPriority float64) (*Entry, error) {`
`252`	`252`
`253`	`253`	`if heap.IsEmpty() {`
`254`		`- return nil, EmptyHeapError("Cannot decrease key in an empty heap")`
	`254`	`+ return nil, EmptyHeapError("cannot decrease key in an empty heap")`
`255`	`255`	`}`
`256`	`256`
`257`	`257`	`if node == nil {`
`258`		`- return nil, NilError("Cannot decrease key: given node is nil")`
	`258`	`+ return nil, NilError("cannot decrease key: given node is nil")`
`259`	`259`	`}`
`260`	`260`
`261`	`261`	`if newPriority >= node.Priority {`
`262`		`- return nil, fmt.Errorf("The given new priority: %v, is larger than or equal to the old: %v",`
	`262`	`+ return nil, fmt.Errorf("the given new priority: %v, is larger than or equal to the old: %v",`
`263`	`263`	`newPriority, node.Priority)`
`264`	`264`	`}`
`265`	`265`
`@@ -271,11 +271,11 @@ func (heap FloatingFibonacciHeap) DecreaseKey(node Entry, newPriority float64)`
`271`	`271`	`func (heap FloatingFibonacciHeap) Delete(node Entry) error {`
`272`	`272`
`273`	`273`	`if heap.IsEmpty() {`
`274`		`- return EmptyHeapError("Cannot delete element from an empty heap")`
	`274`	`+ return EmptyHeapError("cannot delete element from an empty heap")`
`275`	`275`	`}`
`276`	`276`
`277`	`277`	`if node == nil {`
`278`		`- return NilError("Cannot delete node: given node is nil")`
	`278`	`+ return NilError("cannot delete node: given node is nil")`
`279`	`279`	`}`
`280`	`280`
`281`	`281`	`decreaseKeyUnchecked(heap, node, -math.MaxFloat64)`
`@@ -291,7 +291,7 @@ func (heap FloatingFibonacciHeap) Delete(node Entry) error {`
`291`	`291`	`func (heap FloatingFibonacciHeap) Merge(other FloatingFibonacciHeap) (FloatingFibonacciHeap, error) {`
`292`	`292`
`293`	`293`	`if heap == nil \|\| other == nil {`
`294`		`- return FloatingFibonacciHeap{}, NilError("One of the heaps to merge is nil. Cannot merge")`
	`294`	`+ return FloatingFibonacciHeap{}, NilError("one of the heaps to merge is nil. Cannot merge")`
`295`	`295`	`}`
`296`	`296`
`297`	`297`	`resultSize := heap.size + other.size`