code review 4634073: gc: Escape analysis.

test/escape2.go

 // errchk -0 $G -sm $D/$F.go
 
 // Copyright 2010 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 package foo
 
 import "unsafe"
 
@@ skipping 91 matching lines @@
         **xxx = y
 }
 
 type Bar struct {
         i int
         ii *int
 }
 
 func NewBar() *Bar {
         return &Bar{ 42, nil }
+}
+
+func NewBarp(x *int) *Bar {  // ERROR "leaking param: NAME-x"
+        return &Bar{ 42, x }
+}
+
+func NewBarp2(x *int) *Bar {
+        return &Bar{ *x, nil }
 }
 
 func (b *Bar) NoLeak() int {
         return *(b.ii)
 }
 
 func (b *Bar) AlsoNoLeak() *int {
         return b.ii
 }
 
@@ skipping 424 matching lines @@
 }
 
 func foo77a(z []interface{}) {  // ERROR "leaking param: NAME-z"
         myprint1(nil, z...)
 }
 
 func foo78(z int) *int {  // ERROR "moved to heap: NAME-z"
         return &z  //  "&z escapes"
 }
 
-// move of y is spurious.  see esc.c line 842
 func foo78a(z int) *int {  // ERROR "moved to heap: NAME-z"
-        y := &z   // ERROR "moved to heap: NAME-y"
+        y := &z
         x := &y
         return *x  // really return y
 }
 
 func foo79() *int {
         return new(int)  //  "moved to heap: new[(]int[)]"
 }
 
 func foo80() *int {
         var z *int
@@ skipping 16 matching lines @@
         Foo()
 }
 
 type LimitedFooer struct {
         Fooer
         N int64
 }
 
 func LimitFooer(r Fooer, n int64) Fooer {  // ERROR "leaking param: NAME-r"
         return &LimitedFooer{r, n}
-}
+}
+
+func foo90(x *int) map[*int]*int {  // ERROR "leaking param: NAME-x"
+        return map[*int]*int{ nil: x }
+}
+
+func foo91(x *int) map[*int]*int {  // ERROR "leaking param: NAME-x"
+        return map[*int]*int{ x:nil }
+}
+
+func foo92(x *int) [2]*int {  // ERROR "leaking param: NAME-x"
+        return [2]*int{ x, nil }
+}
+