Change https://golang.org/cl/153841 mentions this issue: cmd/compile: rewrite f(g()) for multi-value g() during typecheck

I uploaded CL 153841 as a proof-of-concept of the idea. It mostly works with two notable caveats:

1. Handling global variable initializers like var v = f(g()) is tricky, because we can't generate autotmps outside of function context. The CL currently uses statictmps instead as a hacky workaround, but something better needs to be done before this can be committed.

2. Error messages need a way to print f(g()) instead of f(.autotmp_1, .autotmp_2).

CL 153841 addresses these concerns now:

1. Temporary variables for globals are allocated to the init function. (Actually, since this function isn't created until later, they're allocated to a dummy ODCLFUNC node; later they're moved and reassociated with the actual init function.)

2. The version from before rewriting is saved in n.Orig, like how constant expressions work.

Inlining sees the post-rewrite form, which means .autotmp_XXX variables can now end up in export bodies, and it increases the naive count-the-nodes cost heuristic used for determining inlinability. Neither of these seem like major issues to me though.

I'll send the CL out for review once the next dev cycle opens.

And for the record, here's a memory corruption bug due to escape analysis mishandling implicit conversions in f(g()) calls:

package main

import "runtime"

type T [4]int

//go:noinline
func f(x, y interface{}) interface{} {
	return x
}

//go:noinline
func g(x []*T) ([]*T, []*T) {
	return x, x
}

func main() {
	c := make(chan int)
	p := new(T)
	runtime.SetFinalizer(p, func(q *T) { println("finalized", q); c <- 0 })
	var s [10]*T
	s[0] = p
	h := f(g(s[:]))
	runtime.GC()
	<-c
	println("accessing", h.([]*T)[0])
}

(Note that this is distinct from the test case in #29353.)

Change https://golang.org/cl/166983 mentions this issue: cmd/compile: rewrite f(g()) for multi-value g() during typecheck