json: internal uses of Append now use new encoder.appendAny

This is necessary for cycle detection to work,
which had been implemented, yet was broken.

Also introduce cachedCodec helper function.

Author: extemporalgenome

json/codec.go

@@ -63,6 +63,17 @@ type (
 // lookup time for simple types like bool, int, etc..
 var cache atomic.Pointer[map[unsafe.Pointer]codec]
 
+func cachedCodec(t reflect.Type) codec {
+	cache := cacheLoad()
+
+	c, found := cache[typeid(t)]
+	if !found {
+		c = constructCachedCodec(t, cache)
+	}
+
+	return c
+}
+
 func cacheLoad() map[unsafe.Pointer]codec {
 	p := cache.Load()
 	if p == nil {

json/encode.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"math"
 	"reflect"
+	"runtime"
 	"sort"
 	"strconv"
 	"sync"
@@ -17,6 +18,23 @@ import (
 
 const hex = "0123456789abcdef"
 
+func (e encoder) appendAny(b []byte, x any) ([]byte, error) {
+	if x == nil {
+		// Special case for nil values because it makes the rest of the code
+		// simpler to assume that it won't be seeing nil pointers.
+		return e.encodeNull(b, nil)
+	}
+
+	t := reflect.TypeOf(x)
+	p := (*iface)(unsafe.Pointer(&x)).ptr
+	c := cachedCodec(t)
+
+	b, err := c.encode(e, b, p)
+	runtime.KeepAlive(x)
+
+	return b, err
+}
+
 func (e encoder) encodeNull(b []byte, p unsafe.Pointer) ([]byte, error) {
 	return append(b, "null"...), nil
 }
@@ -383,7 +401,7 @@ func (e encoder) encodeMapStringInterface(b []byte, p unsafe.Pointer) ([]byte, e
 				b, _ = e.encodeString(b, unsafe.Pointer(&k))
 				b = append(b, ':')
 
-				b, err = Append(b, v, e.flags)
+				b, err = e.appendAny(b, v)
 				if err != nil {
 					return b, err
 				}
@@ -417,7 +435,7 @@ func (e encoder) encodeMapStringInterface(b []byte, p unsafe.Pointer) ([]byte, e
 		b, _ = e.encodeString(b, unsafe.Pointer(&elem.key))
 		b = append(b, ':')
 
-		b, err = Append(b, elem.val, e.flags)
+		b, err = e.appendAny(b, elem.val)
 		if err != nil {
 			break
 		}
@@ -813,11 +831,11 @@ func (e encoder) encodePointer(b []byte, p unsafe.Pointer, t reflect.Type, encod
 }
 
 func (e encoder) encodeInterface(b []byte, p unsafe.Pointer) ([]byte, error) {
-	return Append(b, *(*any)(p), e.flags)
+	return e.appendAny(b, *(*any)(p))
 }
 
 func (e encoder) encodeMaybeEmptyInterface(b []byte, p unsafe.Pointer, t reflect.Type) ([]byte, error) {
-	return Append(b, reflect.NewAt(t, p).Elem().Interface(), e.flags)
+	return e.appendAny(b, reflect.NewAt(t, p).Elem().Interface())
 }
 
 func (e encoder) encodeUnsupportedTypeError(b []byte, p unsafe.Pointer, t reflect.Type) ([]byte, error) {

json/json.go

@@ -6,7 +6,6 @@ import (
 	"io"
 	"math/bits"
 	"reflect"
-	"runtime"
 	"sync"
 	"unsafe"
 )
@@ -194,25 +193,9 @@ func (k Kind) Class() Kind { return Kind(1 << uint(bits.Len(uint(k))-1)) }
 // Append acts like Marshal but appends the json representation to b instead of
 // always reallocating a new slice.
 func Append(b []byte, x any, flags AppendFlags) ([]byte, error) {
-	if x == nil {
-		// Special case for nil values because it makes the rest of the code
-		// simpler to assume that it won't be seeing nil pointers.
-		return append(b, "null"...), nil
-	}
-
-	t := reflect.TypeOf(x)
-	p := (*iface)(unsafe.Pointer(&x)).ptr
-
-	cache := cacheLoad()
-	c, found := cache[typeid(t)]
-
-	if !found {
-		c = constructCachedCodec(t, cache)
-	}
+	e := encoder{flags: flags}
 
-	b, err := c.encode(encoder{flags: flags}, b, p)
-	runtime.KeepAlive(x)
-	return b, err
+	return e.appendAny(b, x)
 }
 
 // Escape is a convenience helper to construct an escaped JSON string from s.
@@ -330,14 +313,9 @@ func Parse(b []byte, x any, flags ParseFlags) ([]byte, error) {
 		}
 		return r, &InvalidUnmarshalError{Type: t}
 	}
-	t = t.Elem()
 
-	cache := cacheLoad()
-	c, found := cache[typeid(t)]
-
-	if !found {
-		c = constructCachedCodec(t, cache)
-	}
+	t = t.Elem()
+	c := cachedCodec(t)
 
 	r, err := c.decode(d, b, p)
 	return skipSpaces(r), err