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

[gostls13.git] / test / escape_field.go

diff --git a/test/escape_field.go b/test/escape_field.go
index 16d1e741b8b6450a2d7786abd2c57f0ee575eed4..95d0784d9167cc9cf358dda69914ef9d0a319af0 100644 (file)
--- a/test/escape_field.go
+++ b/test/escape_field.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.
 
@@ -23,29 +23,29 @@ type Y struct {
 func field0() {
        i := 0 // ERROR "moved to heap: i$"
        var x X
-       x.p1 = &i   // ERROR "&i escapes to heap$"
-       sink = x.p1 // ERROR "x\.p1 escapes to heap"
+       x.p1 = &i
+       sink = x.p1
 }
 
 func field1() {
        i := 0 // ERROR "moved to heap: i$"
        var x X
        // BAD: &i should not escape
-       x.p1 = &i   // ERROR "&i escapes to heap$"
-       sink = x.p2 // ERROR "x\.p2 escapes to heap"
+       x.p1 = &i
+       sink = x.p2
 }
 
 func field3() {
        i := 0 // ERROR "moved to heap: i$"
        var x X
-       x.p1 = &i // ERROR "&i escapes to heap$"
-       sink = x  // ERROR "x escapes to heap"
+       x.p1 = &i
+       sink = x // ERROR "x escapes to heap"
 }
 
 func field4() {
        i := 0 // ERROR "moved to heap: i$"
        var y Y
-       y.x.p1 = &i // ERROR "&i escapes to heap$"
+       y.x.p1 = &i
        x := y.x
        sink = x // ERROR "x escapes to heap"
 }
@@ -54,27 +54,27 @@ func field5() {
        i := 0 // ERROR "moved to heap: i$"
        var x X
        // BAD: &i should not escape here
-       x.a[0] = &i   // ERROR "&i escapes to heap$"
-       sink = x.a[1] // ERROR "x\.a\[1\] escapes to heap"
+       x.a[0] = &i
+       sink = x.a[1]
 }
 
 // BAD: we are not leaking param x, only x.p2
 func field6(x *X) { // ERROR "leaking param content: x$"
-       sink = x.p2 // ERROR "x\.p2 escapes to heap"
+       sink = x.p2
 }
 
 func field6a() {
        i := 0 // ERROR "moved to heap: i$"
        var x X
        // BAD: &i should not escape
-       x.p1 = &i  // ERROR "&i escapes to heap$"
-       field6(&x) // ERROR "field6a &x does not escape"
+       x.p1 = &i
+       field6(&x)
 }
 
 func field7() {
        i := 0
        var y Y
-       y.x.p1 = &i // ERROR "field7 &i does not escape$"
+       y.x.p1 = &i
        x := y.x
        var y1 Y
        y1.x = x
@@ -84,17 +84,17 @@ func field7() {
 func field8() {
        i := 0 // ERROR "moved to heap: i$"
        var y Y
-       y.x.p1 = &i // ERROR "&i escapes to heap$"
+       y.x.p1 = &i
        x := y.x
        var y1 Y
        y1.x = x
-       sink = y1.x.p1 // ERROR "y1\.x\.p1 escapes to heap"
+       sink = y1.x.p1
 }
 
 func field9() {
        i := 0 // ERROR "moved to heap: i$"
        var y Y
-       y.x.p1 = &i // ERROR "&i escapes to heap$"
+       y.x.p1 = &i
        x := y.x
        var y1 Y
        y1.x = x
@@ -105,70 +105,70 @@ func field10() {
        i := 0 // ERROR "moved to heap: i$"
        var y Y
        // BAD: &i should not escape
-       y.x.p1 = &i // ERROR "&i escapes to heap$"
+       y.x.p1 = &i
        x := y.x
        var y1 Y
        y1.x = x
-       sink = y1.x.p2 // ERROR "y1\.x\.p2 escapes to heap"
+       sink = y1.x.p2
 }
 
 func field11() {
-       i := 0         // ERROR "moved to heap: i$"
-       x := X{p1: &i} // ERROR "&i escapes to heap$"
-       sink = x.p1    // ERROR "x\.p1 escapes to heap"
+       i := 0 // ERROR "moved to heap: i$"
+       x := X{p1: &i}
+       sink = x.p1
 }
 
 func field12() {
        i := 0 // ERROR "moved to heap: i$"
        // BAD: &i should not escape
-       x := X{p1: &i} // ERROR "&i escapes to heap$"
-       sink = x.p2    // ERROR "x\.p2 escapes to heap"
+       x := X{p1: &i}
+       sink = x.p2
 }
 
 func field13() {
        i := 0          // ERROR "moved to heap: i$"
-       x := &X{p1: &i} // ERROR "&i escapes to heap$" "field13 &X literal does not escape$"
-       sink = x.p1     // ERROR "x\.p1 escapes to heap"
+       x := &X{p1: &i} // ERROR "&X{...} does not escape$"
+       sink = x.p1
 }
 
 func field14() {
        i := 0 // ERROR "moved to heap: i$"
        // BAD: &i should not escape
-       x := &X{p1: &i} // ERROR "&i escapes to heap$" "field14 &X literal does not escape$"
-       sink = x.p2     // ERROR "x\.p2 escapes to heap"
+       x := &X{p1: &i} // ERROR "&X{...} does not escape$"
+       sink = x.p2
 }
 
 func field15() {
        i := 0          // ERROR "moved to heap: i$"
-       x := &X{p1: &i} // ERROR "&X literal escapes to heap$" "&i escapes to heap$"
-       sink = x        // ERROR "x escapes to heap"
+       x := &X{p1: &i} // ERROR "&X{...} escapes to heap$"
+       sink = x
 }
 
 func field16() {
        i := 0 // ERROR "moved to heap: i$"
        var x X
        // BAD: &i should not escape
-       x.p1 = &i                 // ERROR "&i escapes to heap$"
-       var iface interface{} = x // ERROR "x escapes to heap"
+       x.p1 = &i
+       var iface interface{} = x // ERROR "x does not escape"
        x1 := iface.(X)
-       sink = x1.p2 // ERROR "x1\.p2 escapes to heap"
+       sink = x1.p2
 }
 
 func field17() {
        i := 0 // ERROR "moved to heap: i$"
        var x X
-       x.p1 = &i                 // ERROR "&i escapes to heap$"
-       var iface interface{} = x // ERROR "x escapes to heap"
+       x.p1 = &i
+       var iface interface{} = x // ERROR "x does not escape"
        x1 := iface.(X)
-       sink = x1.p1 // ERROR "x1\.p1 escapes to heap"
+       sink = x1.p1
 }
 
 func field18() {
        i := 0 // ERROR "moved to heap: i$"
        var x X
        // BAD: &i should not escape
-       x.p1 = &i                 // ERROR "&i escapes to heap$"
-       var iface interface{} = x // ERROR "x escapes to heap"
+       x.p1 = &i
+       var iface interface{} = x // ERROR "x does not escape"
        y, _ := iface.(Y)         // Put X, but extracted Y. The cast will fail, so y is zero initialized.
        sink = y                  // ERROR "y escapes to heap"
 }