I don't see any way to change this. Any arbitrary call to the Do method may invoke the function. There is no way to know that the function is no longer needed, so it must be live.

FWIW I also don't see simple ways to change this without API changes. Maybe the compiler could notice that once o.load becomes non-0 it can't ever be 0 again, and once that happens start considering f, and the capture itself, dead (this seems quite difficult to implement though).

Or we could maybe document that if this is a concern, people should manually nil out references (as already done in e.g. some places in the standard library). Adding a something = nil after the runtime.KeepAlive in the example above as expected causes the test to complete immediately.

Is it really even worth documenting as a concern? It seems intuitive to me that the argument to once.Do is live during the call to Do, even if that call doesn't end up executing that argument, because that is the case for essentially every method call in the language already.¹

That is: I think that if you reason about once.Do as an ordinary method call, the concern about reachability is exactly the same as for the argument to any other ordinary method call in a Go program.

¹ With the possible exception of methods that are trivial to inline and unconditionally ignore their arguments.

The current behavior is what I would expect from the current API of sync.Once. If I'm passing a function to sync.Once.Do, then I would expect transitive dependencies of that function to be kept alive even if I mentally knew that it wouldn't be executed.

One way to solve this would be to change the API of sync.Once to accept a function to call, and for it to automatically clear the function once it has been called:

// NewOnceV2 returns a new OnceV2 where f
// is called upon the first call to OnceV2.Do.
func NewOnceV2(f func()) *OnceV2

// OnceV2.Do executes the function passed to NewOnceV2 at most once.
func (*OnceV2) Do() // internal implementation drops reference to f after first call

While the API could allow the function to be garbage collected, I think it has worse properties.

In particular, the compiler may not be able to prove that f doesn't escape and has to heap allocate it. The API today has the benefit that f does not escape when calling sync.Once.Do so that I can pass locally defined closures without worrying about heap allocations.

It seems to me like there may be nothing we can do about this. Closing this for now, but feel free to reopen if that changes!