fix(blocking): drop popped references so pointer T is reclaimable (#54)

* test(blocking): add failing tests for popped-element retention

Get advances the backing slice with [1:] without zeroing the head
slot, and Clear truncates with [:0] without zeroing slots. For
pointer T the backing array still references popped elements, so
they are not GC'd while the queue is alive.

Two runtime-finalizer tests that fail on current main and demonstrate
the retention.

Refs #43

* fix(blocking): zero popped slots so the backing array drops references

Get advanced the slice with elems[:1:] and Clear truncated with
elems[:0]. Neither cleared the underlying array slots, so for pointer
T the queue kept popped elements reachable until the slice
reallocated. Long-lived queues over *T leaked memory.

Zero the popped slot in get() and all slots in Clear().

Fixes #43

* fix: appease wsl_v5 and revive linters

wsl_v5 wants a blank line between the var declaration and the zero
assignment. revive's call-to-gc rule flags runtime.GC() in the
finalizer-driven tests; the calls are intentional so silence them
per-line.

Author: adrianbrad

blocking.go

@@ -154,6 +154,15 @@ func (bq *Blocking[T]) Clear() []T {
 
 	removed := make([]T, len(bq.elems))
 	copy(removed, bq.elems)
+
+	// Drop references into the backing array so popped elements can be
+	// GC'd while the queue outlives them. elems = elems[:0] alone keeps
+	// the underlying slots populated.
+	var zero T
+	for i := range bq.elems {
+		bq.elems[i] = zero
+	}
+
 	bq.elems = bq.elems[:0]
 
 	return removed
@@ -274,6 +283,13 @@ func (bq *Blocking[T]) get() (v T, _ error) {
 	}
 
 	elem := bq.elems[0]
+
+	// Zero the popped slot so the backing array no longer references the
+	// popped element; otherwise pointer T leaks until the slice eventually
+	// reallocates.
+	var zero T
+
+	bq.elems[0] = zero
 	bq.elems = bq.elems[1:]
 
 	bq.notFullCond.Signal()

blocking_test.go

@@ -6,6 +6,7 @@ import (
 	"errors"
 	"fmt"
 	"reflect"
+	"runtime"
 	"sort"
 	"sync"
 	"testing"
@@ -32,6 +33,116 @@ func TestBlocking(t *testing.T) {
 	t.Run("CondWaitWithCapacity", testBlockingCondWaitWithCapacity)
 	t.Run("MarshalJSON", testBlockingMarshalJSON)
 	t.Run("NewDoesNotAliasCallerSlice", testBlockingNewDoesNotAliasCallerSlice)
+	t.Run("GetReleasesReference", testBlockingGetReleasesReference)
+	t.Run("ClearReleasesReferences", testBlockingClearReleasesReferences)
+}
+
+func testBlockingGetReleasesReference(t *testing.T) {
+	t.Parallel()
+
+	type payload struct{ id int }
+
+	var bq *queue.Blocking[*payload]
+
+	finalized := make(chan struct{}, 1)
+
+	// Create the payload in a nested scope so p/got don't keep it alive
+	// after the offer/get cycle.
+	func() {
+		p := &payload{id: 42}
+		runtime.SetFinalizer(p, func(*payload) {
+			finalized <- struct{}{}
+		})
+
+		bq = queue.NewBlocking[*payload](nil)
+
+		if err := bq.Offer(p); err != nil {
+			t.Fatalf("offer: %v", err)
+		}
+
+		got, err := bq.Get()
+		if err != nil {
+			t.Fatalf("get: %v", err)
+		}
+
+		if got != p {
+			t.Fatalf("unexpected element %v", got)
+		}
+	}()
+
+	// Queue is still live. After a successful Get, the queue must not
+	// retain the popped element. Nudge GC until the finalizer fires or
+	// we give up.
+	deadline := time.After(time.Second)
+
+	for {
+		runtime.GC() //nolint:revive // explicit GC needed to drive finalizer
+
+		select {
+		case <-finalized:
+			runtime.KeepAlive(bq)
+			return
+		case <-deadline:
+			runtime.KeepAlive(bq)
+			t.Fatal("popped element not finalized; backing array still holds it")
+		default:
+			time.Sleep(10 * time.Millisecond)
+		}
+	}
+}
+
+func testBlockingClearReleasesReferences(t *testing.T) {
+	t.Parallel()
+
+	type payload struct{ id int }
+
+	var bq *queue.Blocking[*payload]
+
+	finalized := make(chan struct{}, 3)
+
+	func() {
+		items := []*payload{{id: 1}, {id: 2}, {id: 3}}
+
+		for _, it := range items {
+			runtime.SetFinalizer(it, func(*payload) {
+				finalized <- struct{}{}
+			})
+		}
+
+		bq = queue.NewBlocking[*payload](nil)
+
+		for _, it := range items {
+			if err := bq.Offer(it); err != nil {
+				t.Fatalf("offer: %v", err)
+			}
+		}
+
+		cleared := bq.Clear()
+		if len(cleared) != len(items) {
+			t.Fatalf("expected %d cleared, got %d", len(items), len(cleared))
+		}
+	}()
+
+	// All items should be eligible for finalization now — the queue is
+	// empty and the temporary `cleared` slice has gone out of scope.
+	deadline := time.After(time.Second)
+
+	count := 0
+	for count < 3 {
+		runtime.GC() //nolint:revive // explicit GC needed to drive finalizer
+
+		select {
+		case <-finalized:
+			count++
+		case <-deadline:
+			runtime.KeepAlive(bq)
+			t.Fatalf("only %d/3 payloads finalized; Clear kept references", count)
+		default:
+			time.Sleep(10 * time.Millisecond)
+		}
+	}
+
+	runtime.KeepAlive(bq)
 }
 
 func testBlockingNewDoesNotAliasCallerSlice(t *testing.T) {