[coxley]

> because interface{} is always counted as escaped from the stack

Not quite - if the function accepting interface{} can be inlined (and other heuristics are groovy), then it won't escape.

Trivial example but it applies to real-world programs:

    > cat main.go
    package main
    
    import "github.com/google/uuid"
    
    func main() {
            _ = foo(uuid.NewString())
    }
    
    func foo(s any) string {
            switch s := s.(type) {
            case string:
                    _ = "foo:" + s
            }
            return ""
    }
    
    # Build with escape analysis
    > go build -gcflags="-m=2" main.go
    # command-line-arguments
    ./main.go:9:6: can inline foo with cost 13 as: func(any) string { switch statement; return "" }
    ./main.go:5:6: can inline main with cost 77 as: func() { _ = foo(uuid.NewString()) }
    ./main.go:6:9: inlining call to foo
    ./main.go:6:24: uuid.NewString() does not escape
    ./main.go:6:9: "foo:" + s does not escape
    ./main.go:9:10: s does not escape
    ./main.go:12:14: "foo:" + s does not escape

[tapirl]

That is a general rule. Yours is a special case.