Go makes heap allocation doing type assertion on string

func Benchmark_maybeString(b *testing.B) {
	str := "foobar"

	b.ReportAllocs()
	b.ResetTimer()

	for i := 0; i < b.N; i++ {
		_ = maybeString(str)
	}
}

func maybeString(val any) string {
	switch val.(type) {
	case string:
		return val.(string)
	default:
		return ""
	}
}

Benchmark_maybeString        0.3118 ns/op	       0 B/op	       0 allocs/op

However, changing the default case, which doesn't even run in the benchmark, to something more complicated suddenly makes the function allocate:

func maybeString(val any) string {
	switch val.(type) {
	case string:
		return val.(string)
	default:
		return fmt.Sprintf("not a string: %T", val)
	}
}

Benchmark_maybeString	        18.65 ns/op	      16 B/op	       1 allocs/op

Why? If it's because the string is escaping to heap, does it mean Go can allocate strings on the stack? How about the following version, which i assume should be in the heap from the very beginning but still allocates:

data := map[string]string{
	"foobar": time.Now().Format(time.RFC3339),
}
maybeString(data["foobar"])

Figured so far

1. Changing str := "foobar" to const str = "foobar" or var str any = "foobar" makes 0 allocations in both version. Why? Are somehow strings in Go not always allocated equally?

2. The allocating version calls runtime.convTstring() before performing the type assertion CMPL. But what does the go:string."foobar"(SB) syntax mean?

The allocation is due to fmt.Sprintf taking an interface, so the compiler transforms your string into an interface to invoke the function (the runtime.convTstring you see), but apparently the compiler is dumb here.

1, The allocation is only needed in the default case, it should not be put before type switching, pushing the allocation into where it is needed will surely remove the allocation.

2, The other option is to hoist the allocation out of the loop, which also helps eliminate the allocation inside the loop. This requires the compiler to know that the pointer in the iface struct points to a constant, though.

3, The type switch should be folded, I believe this change will fix this.

For your questions:

1, Change str := "foobar" to const str = "foobar" allows the compiler to eliminate the allocation because str lives outside the stack and is constant, so the allocation can be done at compile time. And changing to var str any = "foobar" hoist the allocation outside of the loop, so there is no allocation inside.

2, go:string."foobar"(SB) is the address of the buffer contains the char array "foobar", this line of code loads that address into rax, and the following one loads the length into rbx. This is because runtime.convTstring takes a string, which consists of a pointer and an int. The Go calling convention put the first 2 primitive arguments in rax and rbx, respectively.

It boils down the fact that Go can allocate things on the stack if escape analysis at compile time determines it doesn't escape the current goroutine's stack. Introducing code that passes string to fmt.Sprintf() args makes it decide the string escapes stack.

A version where the string is already outside stack don't allocate. For example:

const str = "foobar"

var str any = "foobar"

str := map[string]any{
	"foobar": fmt.Sprintf("%v", time.Now().Format(time.RFC3339)),
}["foobar"]