fix(fieldorder): recursively detect pointer data in struct/array fields

Copilot review on PR #723 flagged that IsPointerish only checked
reflect.Kind, so a struct field whose own Kind is reflect.Struct (or
reflect.Array) but which itself wraps a pointer-bearing field (e.g. a
nested struct holding a []byte) would be misclassified as scalar --
letting a real GC-ptrdata regression slip past these layout tests
while the package doc comment claims to check "pointer-bearing
fields". None of the four structs this package currently checks
happen to have such a field today, but the gap is real for future
callers. IsPointerish now takes a reflect.Type and recurses into
struct fields and array element types.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LJTrn4DizYTMdYj4tbswVJ

Author: claude

pkg/goldmark/internal/fieldorder/fieldorder.go

@@ -12,14 +12,27 @@ import (
 	"testing"
 )
 
-// IsPointerish reports whether a field's kind carries at least one
-// pointer word that the GC must scan (a pointer, interface, slice,
-// map, chan, func, string header, or unsafe.Pointer).
-func IsPointerish(k reflect.Kind) bool {
-	switch k {
+// IsPointerish reports whether t carries at least one pointer word
+// that the GC must scan: directly (a pointer, interface, slice, map,
+// chan, func, string header, or unsafe.Pointer), or indirectly
+// through a struct field or array element of such a type, checked
+// recursively. A struct's reflect.Kind is always reflect.Struct
+// regardless of what its fields hold, so a Kind-only check would
+// misclassify e.g. a struct wrapping a []byte as scalar.
+func IsPointerish(t reflect.Type) bool {
+	switch t.Kind() {
 	case reflect.Ptr, reflect.Interface, reflect.Slice, reflect.Map,
 		reflect.Chan, reflect.Func, reflect.String, reflect.UnsafePointer:
 		return true
+	case reflect.Struct:
+		for i := 0; i < t.NumField(); i++ {
+			if IsPointerish(t.Field(i).Type) {
+				return true
+			}
+		}
+		return false
+	case reflect.Array:
+		return IsPointerish(t.Elem())
 	}
 	return false
 }
@@ -34,7 +47,7 @@ func AssertPointersBeforeScalars(t testing.TB, typ reflect.Type, skip int) {
 	seenScalar := false
 	for i := skip; i < typ.NumField(); i++ {
 		f := typ.Field(i)
-		if IsPointerish(f.Type.Kind()) {
+		if IsPointerish(f.Type) {
 			if seenScalar {
 				t.Errorf("field %s (%s, pointer-ish) is declared after a scalar field; "+
 					"pointer fields should precede scalars to shrink GC ptrdata",

pkg/goldmark/internal/fieldorder/fieldorder_test.go

@@ -0,0 +1,46 @@
+package fieldorder
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+// nestedPointerish is a struct whose Kind is reflect.Struct but which
+// carries a pointer word (Data) via a nested field — the shape
+// IsPointerish must recognise even though the field itself is not
+// directly a pointer/interface/slice/map/chan/func/string/
+// unsafe.Pointer kind.
+type nestedPointerish struct {
+	Data []byte
+}
+
+func TestIsPointerish_DetectsNestedStructField(t *testing.T) {
+	typ := reflect.TypeOf(nestedPointerish{})
+	assert.True(t, IsPointerish(typ),
+		"a struct containing a pointer-bearing field (here, a []byte) must itself be pointer-ish")
+}
+
+func TestIsPointerish_DetectsArrayOfPointerish(t *testing.T) {
+	typ := reflect.TypeOf([2]nestedPointerish{})
+	assert.True(t, IsPointerish(typ),
+		"an array of pointer-bearing elements must itself be pointer-ish")
+}
+
+func TestIsPointerish_ScalarStructIsNotPointerish(t *testing.T) {
+	type allScalar struct {
+		A int
+		B bool
+		C byte
+	}
+	assert.False(t, IsPointerish(reflect.TypeOf(allScalar{})))
+}
+
+func TestIsPointerish_DirectKinds(t *testing.T) {
+	assert.True(t, IsPointerish(reflect.TypeOf((*int)(nil))))
+	assert.True(t, IsPointerish(reflect.TypeOf("")))
+	assert.True(t, IsPointerish(reflect.TypeOf([]int(nil))))
+	assert.False(t, IsPointerish(reflect.TypeOf(0)))
+	assert.False(t, IsPointerish(reflect.TypeOf(byte(0))))
+}