cmd/compile/internal/inline: score call sites exposed by inlines

[gostls13.git] / test / escape_iface.go

diff --git a/test/escape_iface.go b/test/escape_iface.go
index 2b1144ad2c5aa2d45c2f25832e1cd86118805b5c..d822cca2f8485fa6b263cbb2db1599c9fcd4e0e1 100644 (file)
--- a/test/escape_iface.go
+++ b/test/escape_iface.go
@@ -1,6 +1,6 @@
 // errorcheck -0 -m -l
 
-// Copyright 2015 The Go Authors.  All rights reserved.
+// Copyright 2015 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.
 
@@ -15,7 +15,7 @@ type M interface {
 }
 
 func mescapes(m M) { // ERROR "leaking param: m"
-       sink = m // ERROR "m escapes to heap"
+       sink = m
 }
 
 func mdoesnotescape(m M) { // ERROR "m does not escape"
@@ -32,48 +32,47 @@ func (M0) M() {
 func efaceEscape0() {
        {
                i := 0
-               v := M0{&i} // ERROR "&i does not escape"
-               var x M = v // ERROR "v does not escape"
+               v := M0{&i}
+               var x M = v
                _ = x
        }
        {
-               i := 0      // ERROR "moved to heap: i"
-               v := M0{&i} // ERROR "&i escapes to heap"
-               var x M = v // ERROR "v escapes to heap"
-               sink = x    // ERROR "x escapes to heap"
+               i := 0 // ERROR "moved to heap: i"
+               v := M0{&i}
+               var x M = v
+               sink = x
        }
        {
                i := 0
-               v := M0{&i} // ERROR "&i does not escape"
-               var x M = v // ERROR "v does not escape"
+               v := M0{&i}
+               var x M = v
                v1 := x.(M0)
                _ = v1
        }
        {
-               i := 0      // ERROR "moved to heap: i"
-               v := M0{&i} // ERROR "&i escapes to heap"
+               i := 0 // ERROR "moved to heap: i"
+               v := M0{&i}
                // BAD: v does not escape to heap here
-               var x M = v // ERROR "v escapes to heap"
+               var x M = v
                v1 := x.(M0)
-               sink = v1 // ERROR "v1 escapes to heap"
+               sink = v1
        }
        {
-               i := 0      // ERROR "moved to heap: i"
-               v := M0{&i} // ERROR "&i escapes to heap"
-               // BAD: v does not escape to heap here
-               var x M = v // ERROR "v escapes to heap"
-               x.M()
+               i := 0
+               v := M0{&i}
+               var x M = v
+               x.M() // ERROR "devirtualizing x.M"
        }
        {
-               i := 0      // ERROR "moved to heap: i"
-               v := M0{&i} // ERROR "&i escapes to heap"
-               var x M = v // ERROR "v escapes to heap"
+               i := 0 // ERROR "moved to heap: i"
+               v := M0{&i}
+               var x M = v
                mescapes(x)
        }
        {
                i := 0
-               v := M0{&i} // ERROR "&i does not escape"
-               var x M = v // ERROR "v does not escape"
+               v := M0{&i}
+               var x M = v
                mdoesnotescape(x)
        }
 }
@@ -90,48 +89,46 @@ func (M1) M() {
 func efaceEscape1() {
        {
                i := 0
-               v := M1{&i, 0} // ERROR "&i does not escape"
-               var x M = v    // ERROR "v does not escape"
+               v := M1{&i, 0}
+               var x M = v // ERROR "v does not escape"
                _ = x
        }
        {
-               i := 0         // ERROR "moved to heap: i"
-               v := M1{&i, 0} // ERROR "&i escapes to heap"
-               var x M = v    // ERROR "v escapes to heap"
-               sink = x       // ERROR "x escapes to heap"
+               i := 0 // ERROR "moved to heap: i"
+               v := M1{&i, 0}
+               var x M = v // ERROR "v escapes to heap"
+               sink = x
        }
        {
                i := 0
-               v := M1{&i, 0} // ERROR "&i does not escape"
-               var x M = v    // ERROR "v does not escape"
+               v := M1{&i, 0}
+               var x M = v // ERROR "v does not escape"
                v1 := x.(M1)
                _ = v1
        }
        {
-               i := 0         // ERROR "moved to heap: i"
-               v := M1{&i, 0} // ERROR "&i escapes to heap"
-               // BAD: v does not escape to heap here
-               var x M = v // ERROR "v escapes to heap"
+               i := 0 // ERROR "moved to heap: i"
+               v := M1{&i, 0}
+               var x M = v // ERROR "v does not escape"
                v1 := x.(M1)
                sink = v1 // ERROR "v1 escapes to heap"
        }
        {
-               i := 0         // ERROR "moved to heap: i"
-               v := M1{&i, 0} // ERROR "&i escapes to heap"
-               // BAD: v does not escape to heap here
-               var x M = v // ERROR "v escapes to heap"
-               x.M()
+               i := 0
+               v := M1{&i, 0}
+               var x M = v // ERROR "v does not escape"
+               x.M()       // ERROR "devirtualizing x.M"
        }
        {
-               i := 0         // ERROR "moved to heap: i"
-               v := M1{&i, 0} // ERROR "&i escapes to heap"
-               var x M = v    // ERROR "v escapes to heap"
+               i := 0 // ERROR "moved to heap: i"
+               v := M1{&i, 0}
+               var x M = v // ERROR "v escapes to heap"
                mescapes(x)
        }
        {
                i := 0
-               v := M1{&i, 0} // ERROR "&i does not escape"
-               var x M = v    // ERROR "v does not escape"
+               v := M1{&i, 0}
+               var x M = v // ERROR "v does not escape"
                mdoesnotescape(x)
        }
 }
@@ -147,65 +144,64 @@ func (*M2) M() {
 func efaceEscape2() {
        {
                i := 0
-               v := &M2{&i} // ERROR "&i does not escape" "&M2 literal does not escape"
-               var x M = v  // ERROR "v does not escape"
+               v := &M2{&i} // ERROR "&M2{...} does not escape"
+               var x M = v
                _ = x
        }
        {
                i := 0       // ERROR "moved to heap: i"
-               v := &M2{&i} // ERROR "&i escapes to heap" "&M2 literal escapes to heap"
-               var x M = v  // ERROR "v escapes to heap"
-               sink = x     // ERROR "x escapes to heap"
+               v := &M2{&i} // ERROR "&M2{...} escapes to heap"
+               var x M = v
+               sink = x
        }
        {
                i := 0
-               v := &M2{&i} // ERROR "&i does not escape" "&M2 literal does not escape"
-               var x M = v  // ERROR "v does not escape"
+               v := &M2{&i} // ERROR "&M2{...} does not escape"
+               var x M = v
                v1 := x.(*M2)
                _ = v1
        }
        {
                i := 0       // ERROR "moved to heap: i"
-               v := &M2{&i} // ERROR "&i escapes to heap" "&M2 literal escapes to heap"
+               v := &M2{&i} // ERROR "&M2{...} escapes to heap"
                // BAD: v does not escape to heap here
-               var x M = v // ERROR "v escapes to heap"
+               var x M = v
                v1 := x.(*M2)
-               sink = v1 // ERROR "v1 escapes to heap"
+               sink = v1
        }
        {
                i := 0       // ERROR "moved to heap: i"
-               v := &M2{&i} // ERROR "&i escapes to heap" "&M2 literal does not escape"
+               v := &M2{&i} // ERROR "&M2{...} does not escape"
                // BAD: v does not escape to heap here
-               var x M = v // ERROR "v does not escape"
+               var x M = v
                v1 := x.(*M2)
-               sink = *v1 // ERROR "v1 escapes to heap"
+               sink = *v1
        }
        {
                i := 0       // ERROR "moved to heap: i"
-               v := &M2{&i} // ERROR "&i escapes to heap" "&M2 literal does not escape"
+               v := &M2{&i} // ERROR "&M2{...} does not escape"
                // BAD: v does not escape to heap here
-               var x M = v // ERROR "v does not escape"
+               var x M = v
                v1, ok := x.(*M2)
-               sink = *v1 // ERROR "v1 escapes to heap"
+               sink = *v1
                _ = ok
        }
        {
-               i := 0       // ERROR "moved to heap: i"
-               v := &M2{&i} // ERROR "&i escapes to heap" "&M2 literal escapes to heap"
-               // BAD: v does not escape to heap here
-               var x M = v // ERROR "v escapes to heap"
-               x.M()
+               i := 0
+               v := &M2{&i} // ERROR "&M2{...} does not escape"
+               var x M = v
+               x.M() // ERROR "devirtualizing x.M"
        }
        {
                i := 0       // ERROR "moved to heap: i"
-               v := &M2{&i} // ERROR "&i escapes to heap" "&M2 literal escapes to heap"
-               var x M = v  // ERROR "v escapes to heap"
+               v := &M2{&i} // ERROR "&M2{...} escapes to heap"
+               var x M = v
                mescapes(x)
        }
        {
                i := 0
-               v := &M2{&i} // ERROR "&i does not escape" "&M2 literal does not escape"
-               var x M = v  // ERROR "v does not escape"
+               v := &M2{&i} // ERROR "&M2{...} does not escape"
+               var x M = v
                mdoesnotescape(x)
        }
 }
@@ -220,8 +216,50 @@ type T2 struct {
 
 func dotTypeEscape() *T2 { // #11931
        var x interface{}
-       x = &T1{p: new(int)} // ERROR "new\(int\) escapes to heap" "&T1 literal does not escape"
-       return &T2{
-               T1: *(x.(*T1)), // ERROR "&T2 literal escapes to heap"
+       x = &T1{p: new(int)} // ERROR "new\(int\) escapes to heap" "&T1{...} does not escape"
+       return &T2{          // ERROR "&T2{...} escapes to heap"
+               T1: *(x.(*T1)),
+       }
+}
+
+func dotTypeEscape2() { // #13805, #15796
+       {
+               i := 0
+               j := 0
+               var v int
+               var ok bool
+               var x interface{} = i // ERROR "i does not escape"
+               var y interface{} = j // ERROR "j does not escape"
+
+               *(&v) = x.(int)
+               *(&v), *(&ok) = y.(int)
+       }
+       { // #13805, #15796
+               i := 0
+               j := 0
+               var ok bool
+               var x interface{} = i // ERROR "i does not escape"
+               var y interface{} = j // ERROR "j does not escape"
+
+               sink = x.(int)         // ERROR "x.\(int\) escapes to heap"
+               sink, *(&ok) = y.(int) // ERROR "autotmp_.* escapes to heap"
        }
+       {
+               i := 0 // ERROR "moved to heap: i"
+               j := 0 // ERROR "moved to heap: j"
+               var ok bool
+               var x interface{} = &i
+               var y interface{} = &j
+
+               sink = x.(*int)
+               sink, *(&ok) = y.(*int)
+       }
+}
+
+func issue42279() {
+       type I interface{ M() }
+       type T struct{ I }
+
+       var i I = T{} // ERROR "T\{\} does not escape"
+       i.M()         // ERROR "partially devirtualizing i.M to T"
 }