I can't think of any case where the slice passed to append must be forced to be heap allocated.

The other argument(s) to append might need to be though. Consider the following program:

package main

import (
	"fmt"
	_ "unsafe"
)

type Builder struct {
	buf []*byte
}

func (b *Builder) DoSth(n byte) {
	b.buf = append2(b.buf, &n)
}

//go:noescape
//go:linkname append2 main.append2helper
func append2(buf []*byte, elems ...*byte) []*byte

func append2helper(buf []*byte, elems ...*byte) []*byte {
	return append(buf, elems...)
}

func main() {
	b := new(Builder)
	b.DoSth(1)
	b.DoSth(2)
	b.DoSth(3)

	for i := range b.buf {
		fmt.Print(*b.buf[i])
	}
	fmt.Println()
}

If you run this with inlining disabled (-gcflags=-l) then it will output 333 instead of 123.

Change https://go.dev/cl/425462 mentions this issue: cmd/compile/internal/escape: optimize b.buf = append(b.buf, ...)

I've prototyped the requested optimization in CL 425462 above. Please test it out on more realistic code bases and report back if it helps. (Beware: I'm reasonably confident that it's correct, but I wouldn't recommend using it for any production workloads yet.)

Also, know that it's currently very restrictive on the expressions that can appear in the append arguments list. I think this can be relaxed, but in the mean time you may need to manually spill the values into temporary variables.

For example, compiling the source file below with go tool build -gcflags=-m now reports (*Builder).DoSth ignoring self-assignment in b.buf = append(b.buf, p) and make([]*byte, 0, 10) does not escape, while also still printing the correct output "123".

package main

import (
	"fmt"
)

type Builder struct {
	buf []*byte
}

func (b *Builder) DoSth(n byte) {
	p := &n
	b.buf = append(b.buf, p)
}

func main() {
	b := &Builder{buf: make([]*byte, 0, 10)}
	b.DoSth(1)
	b.DoSth(2)
	b.DoSth(3)

	for i := range b.buf {
		fmt.Print(*b.buf[i])
	}
	fmt.Println()
}

It seems to work fine.

The only problem that I found is while passing the b.buf to some external function, which appends to that buf, it still escapes.

type Builder struct {
	buf []byte
}

func (b *Builder) DoSth(n byte) {
	b.buf = doSth(b.buf, 3)
}

func doSth(msg []byte, n byte) []byte {
	return append(msg, n)
}

func main() {
	b := &Builder{buf: make([]byte, 0, 10)}
	b.DoSth(1)
}

But it is not a big deal, while using pointers the alloc is removed:

func (b *Builder) DoSth2(n byte) {
	doSth2(&b.buf, 3)
}

func doSth2(msg *[]byte, n byte) {
	*msg = append(*msg, n)
}

func main() {
	b := &Builder{buf: make([]byte, 0, 10)}
	b.DoSth2(1)
}