Use new slices package available in Go 1.21 (#289)

Author: dsnet

arshal_default.go

@@ -13,7 +13,7 @@ import (
 	"fmt"
 	"math"
 	"reflect"
-	"sort"
+	"slices"
 	"strconv"
 	"sync"
 )
@@ -714,9 +714,8 @@ func makeMapArshaler(t reflect.Type) *arshaler {
 				// TODO: If AllowDuplicateNames is enabled, then sort according
 				// to reflect.Value as well if the names are equal.
 				// See internal/fmtsort.
-				// TODO(https://go.dev/issue/47619): Use slices.SortFunc instead.
-				sort.Slice(members, func(i, j int) bool {
-					return lessUTF16(members[i].name, members[j].name)
+				slices.SortFunc(members, func(x, y member) int {
+					return compareUTF16(x.name, y.name)
 				})
 				for _, member := range members {
 					if err := enc.WriteToken(String(member.name)); err != nil {

decode.go

@@ -9,6 +9,7 @@ import (
 	"errors"
 	"io"
 	"math"
+	"slices"
 	"strconv"
 	"unicode/utf16"
 	"unicode/utf8"
@@ -1301,10 +1302,7 @@ func consumeStringResumable(flags *valueFlags, b []byte, resumeOffset int, valid
 // but the error will be specified as having encountered such an error.
 // The input must be an entire JSON string with no surrounding whitespace.
 func unescapeString[Bytes ~[]byte | ~string](dst []byte, src Bytes) (v []byte, err error) {
-	// TODO(https://go.dev/issue/57433): Use slices.Grow.
-	if dst == nil {
-		dst = make([]byte, 0, len(src))
-	}
+	dst = slices.Grow(dst, len(src))
 
 	// Consume the leading double quote.
 	var i, n int

encode.go

@@ -9,6 +9,7 @@ import (
 	"io"
 	"math"
 	"math/bits"
+	"slices"
 	"strconv"
 	"unicode/utf16"
 	"unicode/utf8"
@@ -1002,10 +1003,7 @@ func (e *Encoder) StackPointer() string {
 // except for whether a forward solidus '/' may be formatted as '\/' and
 // the casing of hexadecimal Unicode escape sequences.
 func appendString[Bytes ~[]byte | ~string](dst []byte, src Bytes, validateUTF8 bool, escapeRune func(rune) bool) ([]byte, error) {
-	// TODO(https://go.dev/issue/57433): Use slices.Grow.
-	if dst == nil {
-		dst = make([]byte, 0, len(`"`)+len(src)+len(`"`))
-	}
+	dst = slices.Grow(dst, len(`"`)+len(src)+len(`"`))
 
 	var i, n int
 	var hasInvalidUTF8 bool

fields.go

@@ -5,17 +5,16 @@
 package json
 
 import (
+	"cmp"
 	"errors"
 	"fmt"
 	"io"
 	"reflect"
-	"sort"
+	"slices"
 	"strconv"
 	"strings"
 	"unicode"
 	"unicode/utf8"
-
-	"golang.org/x/exp/slices"
 )
 
 var errIgnoredField = errors.New("ignored field")
@@ -228,14 +227,18 @@ func makeStructFields(root reflect.Type) (structFields, *SemanticError) {
 	// or the one that is uniquely tagged with a JSON name.
 	// Otherwise, no dominant field exists for the set.
 	flattened := allFields[:0]
-	sort.Slice(allFields, func(i, j int) bool {
-		switch fi, fj := allFields[i], allFields[j]; {
-		case fi.name != fj.name:
-			return fi.name < fj.name
-		case len(fi.index) != len(fj.index):
-			return len(fi.index) < len(fj.index)
+	slices.SortFunc(allFields, func(x, y structField) int {
+		switch {
+		case x.name != y.name:
+			return strings.Compare(x.name, y.name)
+		case len(x.index) != len(y.index):
+			return cmp.Compare(len(x.index), len(y.index))
+		case x.hasName && !y.hasName:
+			return -1
+		case !x.hasName && y.hasName:
+			return +1
 		default:
-			return fi.hasName && !fj.hasName
+			return 0 // TODO(https://go.dev/issue/61643): Compare bools better.
 		}
 	})
 	for len(allFields) > 0 {
@@ -252,17 +255,17 @@ func makeStructFields(root reflect.Type) (structFields, *SemanticError) {
 	// Sort the fields according to a breadth-first ordering
 	// so that we can re-number IDs with the smallest possible values.
 	// This optimizes use of uintSet such that it fits in the 64-entry bit set.
-	sort.Slice(flattened, func(i, j int) bool {
-		return flattened[i].id < flattened[j].id
+	slices.SortFunc(flattened, func(x, y structField) int {
+		return cmp.Compare(x.id, y.id)
 	})
 	for i := range flattened {
 		flattened[i].id = i
 	}
 
 	// Sort the fields according to a depth-first ordering
 	// as the typical order that fields are marshaled.
-	sort.Slice(flattened, func(i, j int) bool {
-		return slices.Compare(flattened[i].index, flattened[j].index) < 0
+	slices.SortFunc(flattened, func(x, y structField) int {
+		return slices.Compare(x.index, y.index)
 	})
 
 	// Compute the mapping of fields in the byActualName map.
@@ -281,8 +284,8 @@ func makeStructFields(root reflect.Type) (structFields, *SemanticError) {
 		if len(fields) > 1 {
 			// The precedence order for conflicting nocase names
 			// is by breadth-first order, rather than depth-first order.
-			sort.Slice(fields, func(i, j int) bool {
-				return fields[i].id < fields[j].id
+			slices.SortFunc(fields, func(x, y *structField) int {
+				return cmp.Compare(x.id, y.id)
 			})
 			fs.byFoldedName[foldedName] = fields
 		}

go.mod

@@ -4,5 +4,3 @@
 module github.com/go-json-experiment/json
 
 go 1.21
-
-require golang.org/x/exp v0.0.0-20230315142452-642cacee5cc0

go.sum

@@ -1,2 +0,0 @@
-golang.org/x/exp v0.0.0-20230315142452-642cacee5cc0 h1:pVgRXcIictcr+lBQIFeiwuwtDIs4eL21OuM9nyAADmo=
-golang.org/x/exp v0.0.0-20230315142452-642cacee5cc0/go.mod h1:CxIveKay+FTh1D0yPZemJVgC/95VzuuOLq5Qi4xnoYc=

pools.go

@@ -8,7 +8,7 @@ import (
 	"bytes"
 	"io"
 	"math/bits"
-	"sort"
+	"slices"
 	"sync"
 )
 
@@ -173,10 +173,5 @@ func putStrings(s *stringSlice) {
 
 // Sort sorts the string slice according to RFC 8785, section 3.2.3.
 func (ss *stringSlice) Sort() {
-	// TODO(https://go.dev/issue/47619): Use slices.SortFunc instead.
-	sort.Sort(ss)
+	slices.SortFunc(*ss, func(x, y string) int { return compareUTF16(x, y) })
 }
-
-func (ss *stringSlice) Len() int           { return len(*ss) }
-func (ss *stringSlice) Less(i, j int) bool { return lessUTF16((*ss)[i], (*ss)[j]) }
-func (ss *stringSlice) Swap(i, j int)      { (*ss)[i], (*ss)[j] = (*ss)[j], (*ss)[i] }

testdata_test.go

@@ -8,9 +8,10 @@ import (
 	"bytes"
 	"compress/gzip"
 	"io"
+	"io/fs"
 	"os"
 	"path/filepath"
-	"sort"
+	"slices"
 	"strings"
 	"sync"
 	"testing"
@@ -34,7 +35,7 @@ func jsonTestdata() []jsonTestdataEntry {
 		if err != nil {
 			panic(err)
 		}
-		sort.Slice(fis, func(i, j int) bool { return fis[i].Name() < fis[j].Name() })
+		slices.SortFunc(fis, func(x, y fs.DirEntry) int { return strings.Compare(x.Name(), y.Name()) })
 		for _, fi := range fis {
 			if !strings.HasSuffix(fi.Name(), ".json.gz") {
 				break

value.go

@@ -6,9 +6,11 @@ package json
 
 import (
 	"bytes"
+	"cmp"
 	"errors"
 	"io"
-	"sort"
+	"slices"
+	"strings"
 	"sync"
 	"unicode/utf16"
 	"unicode/utf8"
@@ -204,26 +206,20 @@ type memberName struct {
 	before, after int64
 }
 
-var memberNamePool = sync.Pool{New: func() any { return new(memberNames) }}
+var memberNamePool = sync.Pool{New: func() any { return new([]memberName) }}
 
-func getMemberNames() *memberNames {
-	ns := memberNamePool.Get().(*memberNames)
+func getMemberNames() *[]memberName {
+	ns := memberNamePool.Get().(*[]memberName)
 	*ns = (*ns)[:0]
 	return ns
 }
-func putMemberNames(ns *memberNames) {
+func putMemberNames(ns *[]memberName) {
 	if cap(*ns) < 1<<10 {
 		clear(*ns) // avoid pinning name
 		memberNamePool.Put(ns)
 	}
 }
 
-type memberNames []memberName
-
-func (m *memberNames) Len() int           { return len(*m) }
-func (m *memberNames) Less(i, j int) bool { return lessUTF16((*m)[i].name, (*m)[j].name) }
-func (m *memberNames) Swap(i, j int)      { (*m)[i], (*m)[j] = (*m)[j], (*m)[i] }
-
 // reorderObjects recursively reorders all object members in place
 // according to the ordering specified in RFC 8785, section 3.2.3.
 //
@@ -258,7 +254,7 @@ func reorderObjects(d *Decoder, scratch *[]byte) {
 			afterValue := d.InputOffset()
 
 			if isSorted && len(*members) > 0 {
-				isSorted = lessUTF16(prevName, []byte(name))
+				isSorted = compareUTF16(prevName, []byte(name)) < 0
 			}
 			*members = append(*members, memberName{name, beforeName, afterValue})
 			prevName = name
@@ -270,8 +266,9 @@ func reorderObjects(d *Decoder, scratch *[]byte) {
 		if isSorted {
 			return
 		}
-		// TODO(https://go.dev/issue/47619): Use slices.Sort.
-		sort.Sort(members)
+		slices.SortFunc(*members, func(x, y memberName) int {
+			return compareUTF16(x.name, y.name)
+		})
 
 		// Append the reordered members to a new buffer,
 		// then copy the reordered members back over the original members.
@@ -308,11 +305,11 @@ func reorderObjects(d *Decoder, scratch *[]byte) {
 	}
 }
 
-// lessUTF16 reports whether x is lexicographically less than y according
+// compareUTF16 lexicographically compares x to y according
 // to the UTF-16 codepoints of the UTF-8 encoded input strings.
 // This implements the ordering specified in RFC 8785, section 3.2.3.
 // The inputs must be valid UTF-8, otherwise this may panic.
-func lessUTF16[Bytes ~[]byte | ~string](x, y Bytes) bool {
+func compareUTF16[Bytes ~[]byte | ~string](x, y Bytes) int {
 	// NOTE: This is an optimized, allocation-free implementation
 	// of lessUTF16Simple in fuzz_test.go. FuzzLessUTF16 verifies that the
 	// two implementations agree on the result of comparing any two strings.
@@ -326,15 +323,15 @@ func lessUTF16[Bytes ~[]byte | ~string](x, y Bytes) bool {
 	for {
 		if len(x) == 0 || len(y) == 0 {
 			if len(x) == len(y) && invalidUTF8 {
-				return string(x0) < string(y0)
+				return strings.Compare(string(x0), string(y0))
 			}
-			return len(x) < len(y)
+			return cmp.Compare(len(x), len(y))
 		}
 
 		// ASCII fast-path.
 		if x[0] < utf8.RuneSelf || y[0] < utf8.RuneSelf {
 			if x[0] != y[0] {
-				return x[0] < y[0]
+				return cmp.Compare(x[0], y[0])
 			}
 			x, y = x[1:], y[1:]
 			continue
@@ -357,7 +354,7 @@ func lessUTF16[Bytes ~[]byte | ~string](x, y Bytes) bool {
 			rx, _ = utf16.EncodeRune(rx)
 		}
 		if rx != ry {
-			return rx < ry
+			return cmp.Compare(rx, ry)
 		}
 		invalidUTF8 = invalidUTF8 || (rx == utf8.RuneError && nx == 1) || (ry == utf8.RuneError && ny == 1)
 		x, y = x[nx:], y[ny:]

value_test.go

@@ -5,8 +5,11 @@
 package json
 
 import (
+	"bytes"
+	"cmp"
 	"io"
 	"reflect"
+	"slices"
 	"strings"
 	"testing"
 	"unicode/utf16"
@@ -195,54 +198,45 @@ func TestRawValueMethods(t *testing.T) {
 	}
 }
 
-var lessUTF16Testdata = []string{"", "\r", "1", "\u0080", "\u00f6", "\u20ac", "\U0001f600", "\ufb33"}
+var compareUTF16Testdata = []string{"", "\r", "1", "\u0080", "\u00f6", "\u20ac", "\U0001f600", "\ufb33"}
 
-func TestLessUTF16(t *testing.T) {
-	for i, si := range lessUTF16Testdata {
-		for j, sj := range lessUTF16Testdata {
-			got := lessUTF16([]byte(si), []byte(sj))
-			want := i < j
+func TestCompareUTF16(t *testing.T) {
+	for i, si := range compareUTF16Testdata {
+		for j, sj := range compareUTF16Testdata {
+			got := compareUTF16([]byte(si), []byte(sj))
+			want := cmp.Compare(i, j)
 			if got != want {
-				t.Errorf("lessUTF16(%q, %q) = %v, want %v", si, sj, got, want)
+				t.Errorf("compareUTF16(%q, %q) = %v, want %v", si, sj, got, want)
 			}
 		}
 	}
 }
 
-func FuzzLessUTF16(f *testing.F) {
-	for _, td1 := range lessUTF16Testdata {
-		for _, td2 := range lessUTF16Testdata {
+func FuzzCompareUTF16(f *testing.F) {
+	for _, td1 := range compareUTF16Testdata {
+		for _, td2 := range compareUTF16Testdata {
 			f.Add([]byte(td1), []byte(td2))
 		}
 	}
 
-	// lessUTF16Simple is identical to lessUTF16,
+	// compareUTF16Simple is identical to compareUTF16,
 	// but relies on naively converting a string to a []uint16 codepoints.
 	// It is easy to verify as correct, but is slow.
-	lessUTF16Simple := func(x, y []byte) bool {
+	compareUTF16Simple := func(x, y []byte) int {
 		ux := utf16.Encode([]rune(string(x)))
 		uy := utf16.Encode([]rune(string(y)))
-		// TODO(https://go.dev/issue/57433): Use slices.Compare.
-		for {
-			if len(ux) == 0 || len(uy) == 0 {
-				if len(ux) == len(uy) {
-					return string(x) < string(y)
-				}
-				return len(ux) < len(uy)
-			}
-			if ux[0] != uy[0] {
-				return ux[0] < uy[0]
-			}
-			ux, uy = ux[1:], uy[1:]
+		if n := slices.Compare(ux, uy); n != 0 {
+			return n
 		}
+		return bytes.Compare(x, y) // only occurs for strings with invalid UTF-8
 	}
 
 	f.Fuzz(func(t *testing.T, s1, s2 []byte) {
 		// Compare the optimized and simplified implementations.
-		got := lessUTF16(s1, s2)
-		want := lessUTF16Simple(s1, s2)
+		got := compareUTF16(s1, s2)
+		want := compareUTF16Simple(s1, s2)
 		if got != want {
-			t.Errorf("lessUTF16(%q, %q) = %v, want %v", s1, s2, got, want)
+			t.Errorf("compareUTF16(%q, %q) = %v, want %v", s1, s2, got, want)
 		}
 	})
 }