test: pin a caller's pointer to a slice, map or pointer as a QUIRK (#106)

Set descends into a pointer the caller allocated only when it points
at a struct. A caller's *[]T, *map[K]T or **T, as a field or a slice
element, is left alone: what it holds gets no defaults, a default that
would fail there is not reported, and a tag on the pointer stops at
it. Yet a *[]T or *map[K]T held as a map value is descended into, as
it has been since v1.6.0, whose map loop follows a pointer to a
struct, slice or map. Nothing pinned the skip, and the README said
only that a pointer to a struct is descended into:

    slice := []inner{{}} // inner has Name string `default:"inner"`
    err := defaults.Set(&struct{ Ptr *[]inner }{Ptr: &slice})
    // err=<nil>, slice[0].Name == ""

The README's Maps paragraph and the Set doc, as the commit before this
one wrote them, erred the other way: they said a slice, map or pointer
held as a map value is filled through. A **T map value is not, since
that loop follows a pointer to nothing else.

No library code changes but the Set doc comment. set_pointer_test.go
gains TestSet_CallerPointerToContainerIsSkipped. The README's pointer
paragraph, after the sentence on a pointer to a struct, says that a
pointer the caller allocated to anything else is not descended into,
and that the same *[]T or *map[K]T held as a map value is, though a
**T held as one is not. The Maps paragraph and the Set doc now say
that no map value but a struct is stored back, and that a slice or map
held as a map value is filled through, as is a pointer to a struct,
slice or map, but not a pointer to anything else, such as a **T.

Why this way. #100 descended into all three. The maintainer keeps the
skip instead, as documented behavior. Descending walks every element
behind such a pointer on each Set, which #100 measured as
Walk/pointer/to_filled_slice/elements=1000 going from 163 ns to 182
us, and turns a default that fails there into an error where Set
returned nil. A pointer to a pointer can also lead back to itself with
no struct, slice or map between, which is all the cycle guard earlier
in this stack tracks: a throwaway probe, not committed, of a type
loop *loop pointing at itself passes here and overflows the stack once
Set follows a caller's **T.

Not a behavior change. The QUIRK comment says what is skipped, that a
*[]T or *map[K]T map value is descended into since v1.6.0
(TestSet_MapOfPointerContainers), as a caller's pointer to a struct is
anywhere, and links #100, closed in favor of this pin.

The new test has seven subtests: a caller's *[]T, *map[string]T and
**T field, a *[]T slice element and a **T map value each leave what
they hold unfilled; a tag on a caller's *[]string at a nil slice
leaves the slice nil and the pointer the caller's; and a default that
would fail behind a caller's *[]T is not reported. All pass against
the parent, whose library code this is. The whole suite, go test -race
-shuffle=on -v, gives 311 PASS lines on the parent and 319 here, the 8
new ones added. With #100's library code (a341f0d) and this test
added, six subtests fail, all but the tag one: #100 also kept the tag
from reaching through the caller's pointer. Nothing pinned the skip,
so no test is flipped.

Mutation-checked, 6 of 6 killed, and under each only the new test
fails, so before this commit nothing in the suite noticed any of them.
Descending into a caller's pointer to a slice fails four subtests: the
*[]T field, the slice element, the tag and the failing default. To a
map fails the *map[K]T field, to a pointer the **T field, and to all
three six, all but the **T map value. Following a pointer behind a map
value's pointer, which the Maps paragraph now rules out, fails the **T
map value. Carrying a tag through a caller's pointer to a slice, and
descending no further, fails only the tag subtest. Coverage stays at
100.0%, and make bench-smoke passes all 45 cases.

Replaces #100, which closes in favor of this pin.

Co-authored-by: Claude Opus 5 <noreply@anthropic.com>

Author: creasty

README.md

@@ -76,7 +76,10 @@ default replaces it.
 Use a pointer where that distinction matters. `nil` means unspecified, and a pointer to a zero
 scalar is preserved: `*bool` is the way to let `false` survive a `default:"true"`. A pointer to a
 struct is descended into like the struct itself, though, so the struct's zero fields still get
-their defaults.
+their defaults. A pointer the caller allocated to anything else is not: neither its tag nor the walk
+goes past it, so the elements behind a caller's `*[]T` or `*map[K]T`, and the struct behind a `**T`,
+get no defaults, and a default that would fail there is not reported. The same `*[]T` or `*map[K]T`
+held as a map value is descended into, though a `**T` held as one is not.
 
 ```go
 type Feature struct {
@@ -136,8 +139,9 @@ still being walked, `Set` goes no further, and the walk already under way finish
 A struct held as a map value cannot be filled in place, so `Set` fills a copy and stores it back
 under its key: every such struct it walks, whether or not anything changed. That store is a write to
 the map, so do not call `Set` while another goroutine reads a map of structs it walks, even one with
-nothing left to fill. A slice, map or pointer held as a map value is filled through, and never
-stored back, so `Set` only reads the map holding it.
+nothing left to fill. No other map value is stored back, so `Set` only reads a map of anything else.
+A slice or map held as a map value is filled through, as is a pointer to a struct, slice or map; a
+pointer to anything else, such as a `**T`, is not descended into.
 
 ### Errors
 

set.go

@@ -76,8 +76,9 @@ func (w *walking) repeats() bool {
 // value still being walked, Set goes no further, so a cycle ends.
 //
 // A struct held as a map value is not addressable, so Set fills a copy and stores it back under its
-// key whether or not anything changed: no other goroutine may read that map while Set runs. A slice,
-// map or pointer held as a map value is filled through, and not stored back.
+// key whether or not anything changed: no other goroutine may read that map while Set runs. No
+// other map value is stored back. A slice or map held as a map value is filled through, and so is
+// a pointer to a struct, slice or map, but a pointer to anything else, such as a **T, is not.
 //
 // Set stops at the first field whose default fails and returns its error. A value Set found zero on
 // the way to that default is left zero again, so a second Set fails again; fields filled elsewhere

set_pointer_test.go

@@ -138,6 +138,105 @@ func TestSet_UntaggedPointerStructRecurses(t *testing.T) {
 	assert.Equal(t, child{Name: "Jim", Age: 20}, *got.Child, "the caller's name survives, the missing age is filled")
 }
 
+// TestSet_CallerPointerToContainerIsSkipped covers a pointer the caller allocated to a slice, a map or
+// a pointer, as a field, a slice element and a map value.
+//
+// QUIRK: Set does not descend into such a pointer, so what a caller's *[]T, *map[K]T or **T holds
+// gets no defaults, a default that would fail there is not reported, and a tag on the pointer stops
+// at it. Yet a *[]T or *map[K]T held as a map value is descended into, and has been since v1.6.0
+// (TestSet_MapOfPointerContainers), as a caller's pointer to a struct is anywhere
+// (TestSet_UntaggedPointerStructRecurses). https://github.com/creasty/defaults/pull/100 descended
+// into all three and was closed in favor of this pin: that walks every element behind such a
+// pointer on each Set, and a pointer to a pointer can lead back to itself with no struct, slice or
+// map between, which is all the cycle guard tracks.
+func TestSet_CallerPointerToContainerIsSkipped(t *testing.T) {
+	type inner struct {
+		Name string `default:"inner"`
+	}
+
+	t.Run("a *[]T field", func(t *testing.T) {
+		slice := []inner{{}}
+		got := struct {
+			Ptr *[]inner
+		}{Ptr: &slice}
+
+		require.NoError(t, defaults.Set(&got))
+
+		assert.Empty(t, slice[0].Name)
+	})
+
+	t.Run("a *map[K]T field", func(t *testing.T) {
+		mapping := map[string]inner{"a": {}}
+		got := struct {
+			Ptr *map[string]inner
+		}{Ptr: &mapping}
+
+		require.NoError(t, defaults.Set(&got))
+
+		assert.Empty(t, mapping["a"].Name)
+	})
+
+	t.Run("a **T field", func(t *testing.T) {
+		ptr := &inner{}
+		got := struct {
+			Ptr **inner
+		}{Ptr: &ptr}
+
+		require.NoError(t, defaults.Set(&got))
+
+		assert.Empty(t, ptr.Name)
+	})
+
+	t.Run("a *[]T slice element", func(t *testing.T) {
+		slice := []inner{{}}
+		got := struct {
+			Slices []*[]inner
+		}{Slices: []*[]inner{&slice}}
+
+		require.NoError(t, defaults.Set(&got))
+
+		assert.Empty(t, slice[0].Name)
+	})
+
+	t.Run("a **T map value", func(t *testing.T) {
+		ptr := &inner{}
+		got := struct {
+			Map map[string]**inner
+		}{Map: map[string]**inner{"a": &ptr}}
+
+		require.NoError(t, defaults.Set(&got))
+
+		assert.Empty(t, ptr.Name)
+	})
+
+	t.Run("a tag on a *[]T field", func(t *testing.T) {
+		var slice []string
+		got := struct {
+			Ptr *[]string `default:"[\"tag\"]"`
+		}{Ptr: &slice}
+
+		require.NoError(t, defaults.Set(&got))
+
+		assert.Same(t, &slice, got.Ptr)
+		assert.Nil(t, slice, "the tag does not reach the caller's nil slice")
+	})
+
+	t.Run("a default that would fail behind a *[]T field", func(t *testing.T) {
+		type bad struct {
+			Ints []int `default:"[!]"`
+		}
+
+		slice := []bad{{}}
+		got := struct {
+			Ptr *[]bad
+		}{Ptr: &slice}
+
+		require.NoError(t, defaults.Set(&got))
+
+		assert.Nil(t, slice[0].Ints)
+	})
+}
+
 // TestSet_PointerWithEmptyTag covers `default:""` on a pointer. The tag is present, so the pointer
 // is allocated and points at the zero value — it used to stay nil, which left no way to ask for a
 // pointer to an empty string. See https://github.com/creasty/defaults/issues/52.