Comment 1:

Labels changed: added repo-main.

Comment 2:

Labels changed: added release-none, removed release-go1.4.

Status changed to Accepted.

Similar case from #8615

x := 0
defer func(p *int) {
    *p = 1
}(&x)

What is the current status of this?

Go 1.9 still moves x to heap in this snippet:

package main

func main() {
	x := 0
	func(p *int) {
		*p = 1
	}(&x)
}

build output:

go build -gcflags=-m main.go
# command-line-arguments
./main.go:5:2: can inline main.func1
./main.go:7:4: &x escapes to heap
./main.go:4:7: moved to heap: x
./main.go:5:2: main func literal does not escape
./main.go:5:10: main.func1 p does not escape

This has not been fixed. And as far as I know, no one is working on it.
We don't have enough people to get to every optimization idea, unfortunately.

Dose the current Go1.10 version fix this?

code:

package main

func main() {
    var y int
    func(p *int) {
        *p = 1
    }(&y)
}

go build -gcflags=-m x.go output:

./x.go:5:5: can inline main.func1
./x.go:7:6: inlining call to main.func1
./x.go:7:7: main &y does not escape

Yes, seems like that. Maybe a side-effect of some other optimization. ping @randall77, @josharian

The simple versions were done by @huguesb, I believe, such as c4b65fa. It's not clear to me whether all the cases are done, or if this issue should be kept open.

I think this is still an issue. In the simple example it doesn't happen because the call is inlined, but you can see it if you "go build" with -gcflags=-l to disable inlining.

These are fixed with -newescape=true, and confirmed with updated regress tests.