compress/flate: simplify sorting in huffman_code

src/cmd/compile/internal/test/inl_test.go

@@ -114,9 +114,6 @@ func TestIntendedInlining(t *testing.T) {
 		},
 		"internal/runtime/sys": {},
 		"compress/flate": {
-			"byLiteral.Len",
-			"byLiteral.Less",
-			"byLiteral.Swap",
 			"(*dictDecoder).tryWriteCopy",
 		},
 		"encoding/base64": {
@@ -282,13 +279,6 @@ func TestIntendedInlining(t *testing.T) {
 		}
 	}
 
-	// Functions that must actually be inlined; they must have actual callers.
-	must := map[string]bool{
-		"compress/flate.byLiteral.Len":  true,
-		"compress/flate.byLiteral.Less": true,
-		"compress/flate.byLiteral.Swap": true,
-	}
-
 	notInlinedReason := make(map[string]string)
 	pkgs := make([]string, 0, len(want))
 	for pname, fnames := range want {
@@ -330,12 +320,8 @@ func TestIntendedInlining(t *testing.T) {
 		}
 		if m := canInline.FindStringSubmatch(line); m != nil {
 			fname := m[1]
-			fullname := curPkg + "." + fname
-			// If function must be inlined somewhere, being inlinable is not enough
-			if _, ok := must[fullname]; !ok {
-				delete(notInlinedReason, fullname)
-				continue
-			}
+			delete(notInlinedReason, curPkg+"."+fname)
+			continue
 		}
 		if m := cannotInline.FindStringSubmatch(line); m != nil {
 			fname, reason := m[1], m[2]

src/compress/flate/huffman_code.go

@@ -5,9 +5,10 @@
 package flate
 
 import (
+	"cmp"
 	"math"
 	"math/bits"
-	"sort"
+	"slices"
 )
 
 // hcode is a huffman code with a bit code and bit length.
@@ -19,8 +20,6 @@ type huffmanEncoder struct {
 	codes     []hcode
 	freqcache []literalNode
 	bitCount  [17]int32
-	lns       byLiteral // stored to avoid repeated allocation in generate
-	lfs       byFreq    // stored to avoid repeated allocation in generate
 }
 
 type literalNode struct {
@@ -256,7 +255,9 @@ func (h *huffmanEncoder) assignEncodingAndSize(bitCount []int32, list []literalN
 		// assigned in literal order (not frequency order).
 		chunk := list[len(list)-int(bits):]
 
-		h.lns.sort(chunk)
+		slices.SortFunc(chunk, func(a, b literalNode) int {
+			return cmp.Compare(a.literal, b.literal)
+		})
 		for _, node := range chunk {
 			h.codes[node.literal] = hcode{code: reverseBits(code, uint8(n)), len: uint16(n)}
 			code++
@@ -299,47 +300,19 @@ func (h *huffmanEncoder) generate(freq []int32, maxBits int32) {
 		}
 		return
 	}
-	h.lfs.sort(list)
+	slices.SortFunc(list, func(a, b literalNode) int {
+		if c := cmp.Compare(a.freq, b.freq); c != 0 {
+			return c
+		}
+		return cmp.Compare(a.literal, b.literal)
+	})
 
 	// Get the number of literals for each bit count
 	bitCount := h.bitCounts(list, maxBits)
 	// And do the assignment
 	h.assignEncodingAndSize(bitCount, list)
 }
 
-type byLiteral []literalNode
-
-func (s *byLiteral) sort(a []literalNode) {
-	*s = byLiteral(a)
-	sort.Sort(s)
-}
-
-func (s byLiteral) Len() int { return len(s) }
-
-func (s byLiteral) Less(i, j int) bool {
-	return s[i].literal < s[j].literal
-}
-
-func (s byLiteral) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
-
-type byFreq []literalNode
-
-func (s *byFreq) sort(a []literalNode) {
-	*s = byFreq(a)
-	sort.Sort(s)
-}
-
-func (s byFreq) Len() int { return len(s) }
-
-func (s byFreq) Less(i, j int) bool {
-	if s[i].freq == s[j].freq {
-		return s[i].literal < s[j].literal
-	}
-	return s[i].freq < s[j].freq
-}
-
-func (s byFreq) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
-
 func reverseBits(number uint16, bitLength byte) uint16 {
 	return bits.Reverse16(number << (16 - bitLength))
 }