Consider the following code:

func main() {
	new(FooMessage).ProtoReflect().Type()
}

type FooMessage fooMessage

func (m *FooMessage) ProtoReflect() Message {
	return (*fooMessage)(m)
}

type fooMessage struct{}

func (m *fooMessage) Type() string {
	return "test"
}

type Message interface {
	Type() string
}

When compiled with -gcflags=-m, you see:

./main.go:11:6: can inline (*FooMessage).ProtoReflect
./main.go:17:6: can inline (*fooMessage).Type
./main.go:6:30: inlining call to (*FooMessage).ProtoReflect
./main.go:6:5: new(FooMessage) escapes to heap

Notice how (*fooMessage).Type is inlineable, but the call to it on line 6 is not inlined? As a result, you see that new(FooMessage) escapes to the heap.

It seems that the cause of this is because the (*FooMessage).ProtoReflect function returns an interface. However, at the point when inlining happened, it should know that it has a concrete *fooMessage type instead of any arbitrary Message interface type. Knowing that it has a concrete *fooMessage type, then the call to Type should also be inlined.

If you change the Message return type to *fooMessage, then this inlines as expected:

./main.go:11:6: can inline (*FooMessage).ProtoReflect
./main.go:17:6: can inline (*fooMessage).Type
./main.go:6:30: inlining call to (*FooMessage).ProtoReflect
./main.go:6:37: inlining call to (*fooMessage).Type
./main.go:6:5: main new(FooMessage) does not escape

Furthermore, new(FooMessage) on line 6 no longer escapes.