internal/core/export: swap sort.Slice APIs for slices.Sort

The former uses reflection rather than generics, so a lot of the
slices end up leaking to the heap and allocating.
Moreover, the latter uses cmp functions returning integers,
so fewer comparison calls are needed.

Given that JSON marshalling needs to visit all struct fields
in sorted order, this causes a minor speed-up there.

                            │     old     │                new                │
                            │   sec/op    │   sec/op     vs base              │
    LargeValueMarshalJSON-8   6.484m ± 1%   6.370m ± 1%  -1.77% (p=0.004 n=6)

                            │     old      │                new                 │
                            │     B/op     │     B/op      vs base              │
    LargeValueMarshalJSON-8   4.224Mi ± 0%   4.178Mi ± 0%  -1.09% (p=0.002 n=6)

                            │     old     │                new                │
                            │  allocs/op  │  allocs/op   vs base              │
    LargeValueMarshalJSON-8   62.27k ± 0%   60.26k ± 0%  -3.22% (p=0.002 n=6)

Signed-off-by: Daniel Martí <[email protected]>
Change-Id: I12dbd3bdcfe7ba5f8ef66500203f08f1b5c676ec
Reviewed-on: https://review.gerrithub.io/c/cue-lang/cue/+/1201825
Unity-Result: CUE porcuepine <[email protected]>
TryBot-Result: CUEcueckoo <[email protected]>
Reviewed-by: Roger Peppe <[email protected]>

Author: mvdan

internal/core/export/expr.go

@@ -15,8 +15,9 @@
 package export
 
 import (
+	"cmp"
 	"fmt"
-	"sort"
+	"slices"
 
 	"cuelang.org/go/cue/ast"
 	"cuelang.org/go/cue/token"
@@ -184,17 +185,20 @@ func (x *exporter) mergeValues(label adt.Feature, src *adt.Vertex, a []conjunct,
 	// Sort fields in case features lists are missing to ensure
 	// predictability. Also sort in reverse order, so that bugs
 	// are more likely exposed.
-	sort.Slice(fields, func(i, j int) bool {
-		return fields[i] > fields[j]
+	slices.SortFunc(fields, func(f1, f2 adt.Feature) int {
+		return -cmp.Compare(f1, f2)
 	})
 
 	if adt.DebugSort == 0 {
 		m := sortArcs(extractFeatures(e.structs))
-		sort.SliceStable(fields, func(i, j int) bool {
-			if m[fields[j]] == 0 {
-				return m[fields[i]] != 0
+		slices.SortStableFunc(fields, func(f1, f2 adt.Feature) int {
+			if m[f2] == 0 {
+				if m[f1] == 0 {
+					return +1
+				}
+				return -1
 			}
-			return m[fields[i]] > m[fields[j]]
+			return -cmp.Compare(m[f1], m[f2])
 		})
 	} else {
 		adt.DebugSortFields(e.ctx, fields)

internal/core/export/toposort.go

@@ -15,7 +15,8 @@
 package export
 
 import (
-	"sort"
+	"cmp"
+	"slices"
 
 	"cuelang.org/go/internal/core/adt"
 )
@@ -88,7 +89,7 @@ func sortedArcsFromMap(m map[adt.Feature]int) []adt.Feature {
 		a = append(a, k)
 	}
 
-	sort.Slice(a, func(i, j int) bool { return m[a[i]] > m[a[j]] })
+	slices.SortFunc(a, func(a1, a2 adt.Feature) int { return -cmp.Compare(m[a1], m[a2]) })
 
 	return a
 }