Thus, nothing else should be referencing the underlying value (unless unsafe was used).

I think var sink2 interface{} = sink does reference the underlying value of sink.

I've run into this too, where I have code like:

type T struct {
    F interface{}
}

func ForEach(strs []string, fn func(T)) {
    for _, s := range strs {
        fn(T{F: s})
    }
}

Where T is part of a public API, and F can hold multiple types, like string and map[string]string. I could replace the interface field with many fields of non-interface types, but that would make the public API uglier.

I could also store the values under pointers or struct pointers, assuming that a pointer can fit into an interface without allocating. But that would also make the API a bit more complex and verbose, when it need not be.

I'm wondering if my API design is just bad and will always incur an allocation per iteration, or if the compiler could do something there.

Given @cznic's observation, I don't see what we can do here. Am I missing something?

@josharian kindly pointed out that my case is different, since the value changes at every iteration. So the allocation must be there, at least in the general case.

Closing as unfixable. Please comment or re-open if you think I have this wrong.