refactor: replace sort.SliceStable with slices.SortStableFunc

This commit replaces all the instances of sort.SliceStable with slices.SortStableFunc.
The godocs for sort.SliceStable recommends using slices.SortStableFunc, as it is faster and more efficient.

Author: Surya-7890

cmd/clusterctl/client/repository/components.go

@@ -18,7 +18,7 @@ package repository
 
 import (
 	"fmt"
-	"sort"
+	"slices"
 	"strings"
 
 	"github.com/pkg/errors"
@@ -262,17 +262,20 @@ func NewComponents(input ComponentsInput) (Components, error) {
 	// Deploying cert-manager objects and especially Certificates before Mutating-
 	// ValidatingWebhookConfigurations and CRDs ensures cert-manager's ca-injector
 	// receives the event for the objects at the right time to inject the new CA.
-	sort.SliceStable(objs, func(i, j int) bool {
+	slices.SortStableFunc(objs, func(i, j unstructured.Unstructured) int {
 		// First prioritize Namespaces over everything.
-		if objs[i].GetKind() == "Namespace" {
-			return true
+		if i.GetKind() == "Namespace" {
+			return -1
 		}
-		if objs[j].GetKind() == "Namespace" {
-			return false
+		if j.GetKind() == "Namespace" {
+			return 1
 		}
 
 		// Second prioritize cert-manager objects.
-		return objs[i].GroupVersionKind().Group == "cert-manager.io"
+		if i.GroupVersionKind().Group == "cert-manager.io" {
+			return -1
+		}
+		return 1
 	})
 
 	return &components{

cmd/clusterctl/client/repository/repository_versions.go

@@ -18,7 +18,7 @@ package repository
 
 import (
 	"context"
-	"sort"
+	"slices"
 
 	"github.com/pkg/errors"
 	"k8s.io/apimachinery/pkg/runtime"
@@ -114,17 +114,20 @@ func latestPatchRelease(ctx context.Context, repo Repository, major, minor *int3
 	}
 
 	// Sort parsed versions by semantic version order.
-	sort.SliceStable(versionCandidates, func(i, j int) bool {
+	slices.SortStableFunc(versionCandidates, func(i, j *version.Version) int {
 		// Prioritize release versions over pre-releases. For example v1.0.0 > v2.0.0-alpha
 		// If both are pre-releases, sort by semantic version order as usual.
-		if versionCandidates[j].PreRelease() == "" && versionCandidates[i].PreRelease() != "" {
-			return false
+		if j.PreRelease() == "" && i.PreRelease() != "" {
+			return 1
 		}
-		if versionCandidates[i].PreRelease() == "" && versionCandidates[j].PreRelease() != "" {
-			return true
+		if i.PreRelease() == "" && j.PreRelease() != "" {
+			return -1
 		}
 
-		return versionCandidates[j].LessThan(versionCandidates[i])
+		if j.LessThan(i) {
+			return -1
+		}
+		return 1
 	})
 
 	// Limit the number of searchable versions by 5.

controlplane/kubeadm/internal/workload_cluster_conditions.go

@@ -1070,9 +1070,12 @@ func aggregateConditionsFromMachinesToKCP(input aggregateConditionsFromMachinesT
 		messageIndex = append(messageIndex, m)
 	}
 
-	sort.SliceStable(messageIndex, func(i, j int) bool {
-		return len(messageMap[messageIndex[i]]) > len(messageMap[messageIndex[j]]) ||
-			(len(messageMap[messageIndex[i]]) == len(messageMap[messageIndex[j]]) && strings.Join(messageMap[messageIndex[i]], ",") < strings.Join(messageMap[messageIndex[j]], ","))
+	slices.SortStableFunc(messageIndex, func(i, j string) int {
+		if len(messageMap[i]) > len(messageMap[j]) ||
+			(len(messageMap[i]) == len(messageMap[j]) && strings.Join(messageMap[i], ",") < strings.Join(messageMap[j], ",")) {
+			return -1
+		}
+		return 1
 	})
 
 	// Build the message

internal/controllers/clusterclass/clusterclass_controller.go

@@ -20,7 +20,7 @@ import (
 	"context"
 	"fmt"
 	"reflect"
-	"sort"
+	"slices"
 	"strings"
 
 	"github.com/pkg/errors"
@@ -376,8 +376,11 @@ func (r *Reconciler) reconcileVariables(ctx context.Context, s *scope) (ctrl.Res
 	// Alphabetically sort the variables by name. This ensures no unnecessary updates to the ClusterClass status.
 	// Note: Definitions in `statusVarList[i].Definitions` have a stable order as they are added in a deterministic order
 	// and are always held in an array.
-	sort.SliceStable(statusVarList, func(i, j int) bool {
-		return statusVarList[i].Name < statusVarList[j].Name
+	slices.SortStableFunc(statusVarList, func(i, j clusterv1.ClusterClassStatusVariable) int {
+		if i.Name < j.Name {
+			return -1
+		}
+		return 1
 	})
 	clusterClass.Status.Variables = statusVarList
 

internal/controllers/machineset/machineset_controller.go

@@ -20,7 +20,7 @@ import (
 	"context"
 	"fmt"
 	"math"
-	"sort"
+	"slices"
 	"strings"
 	"time"
 
@@ -1603,17 +1603,23 @@ func (r *Reconciler) reconcileExternalTemplateReference(ctx context.Context, clu
 //   - Machines failing to come up first because
 //     there is a chance that they are not hosting any workloads (minimize disruption).
 func sortMachinesToRemediate(machines []*clusterv1.Machine) {
-	sort.SliceStable(machines, func(i, j int) bool {
-		if annotations.HasRemediateMachine(machines[i]) && !annotations.HasRemediateMachine(machines[j]) {
-			return true
+	slices.SortStableFunc(machines, func(i, j *clusterv1.Machine) int {
+		if annotations.HasRemediateMachine(i) && !annotations.HasRemediateMachine(j) {
+			return -1
 		}
-		if !annotations.HasRemediateMachine(machines[i]) && annotations.HasRemediateMachine(machines[j]) {
-			return false
+		if !annotations.HasRemediateMachine(i) && annotations.HasRemediateMachine(j) {
+			return 1
 		}
 		// Use newest (and Name) as a tie-breaker criteria.
-		if machines[i].CreationTimestamp.Equal(&machines[j].CreationTimestamp) {
-			return machines[i].Name < machines[j].Name
+		if i.CreationTimestamp.Equal(&j.CreationTimestamp) {
+			if i.Name < j.Name {
+				return -1
+			}
+			return 1
+		}
+		if i.CreationTimestamp.After(j.CreationTimestamp.Time) {
+			return -1
 		}
-		return machines[i].CreationTimestamp.After(machines[j].CreationTimestamp.Time)
+		return 1
 	})
 }

internal/controllers/machineset/machineset_controller_test.go

@@ -19,7 +19,7 @@ package machineset
 import (
 	"context"
 	"fmt"
-	"sort"
+	"slices"
 	"strings"
 	"testing"
 	"time"
@@ -3122,8 +3122,11 @@ func TestSortMachinesToRemediate(t *testing.T) {
 		machines := make([]*clusterv1.Machine, len(unhealthyMachines))
 		copy(machines, unhealthyMachines)
 		sortMachinesToRemediate(machines)
-		sort.SliceStable(unhealthyMachines, func(i, j int) bool {
-			return unhealthyMachines[i].CreationTimestamp.After(unhealthyMachines[j].CreationTimestamp.Time)
+		slices.SortStableFunc(unhealthyMachines, func(i, j *clusterv1.Machine) int {
+			if i.CreationTimestamp.After(j.CreationTimestamp.Time) {
+				return -1
+			}
+			return 1
 		})
 		g.Expect(unhealthyMachines).To(Equal(machines))
 	})
@@ -3136,11 +3139,17 @@ func TestSortMachinesToRemediate(t *testing.T) {
 		machines = append(machines, unhealthyMachinesWithAnnotations...)
 		sortMachinesToRemediate(machines)
 
-		sort.SliceStable(unhealthyMachines, func(i, j int) bool {
-			return unhealthyMachines[i].CreationTimestamp.After(unhealthyMachines[j].CreationTimestamp.Time)
+		slices.SortStableFunc(unhealthyMachines, func(i, j *clusterv1.Machine) int {
+			if i.CreationTimestamp.After(j.CreationTimestamp.Time) {
+				return -1
+			}
+			return 1
 		})
-		sort.SliceStable(unhealthyMachinesWithAnnotations, func(i, j int) bool {
-			return unhealthyMachinesWithAnnotations[i].CreationTimestamp.After(unhealthyMachinesWithAnnotations[j].CreationTimestamp.Time)
+		slices.SortStableFunc(unhealthyMachinesWithAnnotations, func(i, j *clusterv1.Machine) int {
+			if i.CreationTimestamp.After(j.CreationTimestamp.Time) {
+				return -1
+			}
+			return 1
 		})
 		g.Expect(machines).To(Equal(append(unhealthyMachinesWithAnnotations, unhealthyMachines...)))
 	})

test/framework/clusterctl/e2e_config.go

@@ -27,7 +27,6 @@ import (
 	"regexp"
 	"runtime"
 	"slices"
-	"sort"
 	"strconv"
 	"strings"
 	"time"
@@ -367,17 +366,20 @@ func resolveReleaseMarker(ctx context.Context, releaseMarker string, goproxyClie
 	}
 
 	// Sort parsed versions by semantic version order.
-	sort.SliceStable(versionCandidates, func(i, j int) bool {
+	slices.SortStableFunc(versionCandidates, func(i, j semver.Version) int {
 		// Prioritize pre-release versions over releases. For example v2.0.0-alpha > v1.0.0
 		// If both are pre-releases, sort by semantic version order as usual.
-		if len(versionCandidates[i].Pre) == 0 && len(versionCandidates[j].Pre) > 0 {
-			return false
+		if len(i.Pre) == 0 && len(j.Pre) > 0 {
+			return 1
 		}
-		if len(versionCandidates[j].Pre) == 0 && len(versionCandidates[i].Pre) > 0 {
-			return true
+		if len(j.Pre) == 0 && len(i.Pre) > 0 {
+			return -1
 		}
 
-		return versionCandidates[j].LT(versionCandidates[i])
+		if j.LT(i) {
+			return -1
+		}
+		return 1
 	})
 
 	// Limit the number of searchable versions by 5.

test/infrastructure/docker/exp/internal/controllers/dockermachinepool_controller_phases.go

@@ -21,7 +21,7 @@ import (
 	"context"
 	"fmt"
 	"math/rand"
-	"sort"
+	"slices"
 
 	"github.com/blang/semver/v4"
 	"github.com/pkg/errors"
@@ -340,10 +340,13 @@ func (r *DockerMachinePoolReconciler) propagateMachineDeleteAnnotation(ctx conte
 // orderByDeleteMachineAnnotation will sort DockerMachines with the clusterv1.DeleteMachineAnnotation to the front of the list.
 // It will preserve the existing order of the list otherwise so that it respects the existing delete priority otherwise.
 func orderByDeleteMachineAnnotation(machines []infrav1.DockerMachine) []infrav1.DockerMachine {
-	sort.SliceStable(machines, func(i, _ int) bool {
-		_, iHasAnnotation := machines[i].Annotations[clusterv1.DeleteMachineAnnotation]
+	slices.SortStableFunc(machines, func(i, _ infrav1.DockerMachine) int {
+		_, iHasAnnotation := i.Annotations[clusterv1.DeleteMachineAnnotation]
 
-		return iHasAnnotation
+		if iHasAnnotation {
+			return -1
+		}
+		return 1
 	})
 
 	return machines

util/conditions/merge_strategies.go

@@ -327,11 +327,14 @@ func sortConditions(conditions []ConditionWithOwnerInfo, orderedConditionTypes [
 		conditionOrder[conditionType] = i
 	}
 
-	sort.SliceStable(conditions, func(i, j int) bool {
+	slices.SortStableFunc(conditions, func(i, j ConditionWithOwnerInfo) int {
 		// Sort by condition order (user defined, useful when computing summary of different conditions from the same object)
-		return conditionOrder[conditions[i].Type] < conditionOrder[conditions[j].Type] ||
+		if conditionOrder[i.Type] < conditionOrder[j.Type] ||
 			// If same condition order, sort by last transition time (useful when computing aggregation of the same conditions from different objects)
-			(conditionOrder[conditions[i].Type] == conditionOrder[conditions[j].Type] && conditions[i].LastTransitionTime.Before(&conditions[j].LastTransitionTime))
+			(conditionOrder[i.Type] == conditionOrder[j.Type] && i.LastTransitionTime.Before(&j.LastTransitionTime)) {
+			return -1
+		}
+		return 1
 	})
 }
 
@@ -463,8 +466,11 @@ func aggregateMessages(conditions []ConditionWithOwnerInfo, n *int, dropEmpty bo
 			messageIndex = append(messageIndex, m)
 		}
 
-		sort.SliceStable(messageIndex, func(i, j int) bool {
-			return sortMessage(messageIndex[i], messageIndex[j], messageMustGoFirst, messagePriorityMap, messageObjMapForKind)
+		slices.SortStableFunc(messageIndex, func(i, j string) int {
+			if sortMessage(i, j, messageMustGoFirst, messagePriorityMap, messageObjMapForKind) {
+				return -1
+			}
+			return 1
 		})
 
 		// Pick the first n messages, decrement n.

util/conditions/patch.go

@@ -18,7 +18,7 @@ package conditions
 
 import (
 	"reflect"
-	"sort"
+	"slices"
 
 	"github.com/google/go-cmp/cmp"
 	"github.com/pkg/errors"
@@ -217,8 +217,11 @@ func (p Patch) Apply(latest Setter, opts ...PatchApplyOption) error {
 	}
 
 	if applyOpt.conditionSortFunc != nil {
-		sort.SliceStable(latestConditions, func(i, j int) bool {
-			return applyOpt.conditionSortFunc(latestConditions[i], latestConditions[j])
+		slices.SortStableFunc(latestConditions, func(i, j metav1.Condition) int {
+			if applyOpt.conditionSortFunc(i, j) {
+				return -1
+			}
+			return 1
 		})
 	}