1
0
mirror of https://github.com/golang/go synced 2024-11-23 07:10:05 -07:00
go/test/escape_iface.go
Matthew Dempsky efb9739203 cmd/compile: use underlying OCOMPLIT's position for OPTRLIT
Currently, when we create an OPTRLIT node, it defaults to the
OCOMPLIT's final element's position. But it improves error messages to
use the OCOMPLIT's own position instead.

Change-Id: Ibb031f543c7248d88d99fd0737685e01d86e2500
Reviewed-on: https://go-review.googlesource.com/c/go/+/197119
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
2019-09-25 17:07:09 +00:00

261 lines
4.5 KiB
Go

// errorcheck -0 -m -l
// 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.
// Test escape analysis for interface conversions.
package escape
var sink interface{}
type M interface {
M()
}
func mescapes(m M) { // ERROR "leaking param: m"
sink = m
}
func mdoesnotescape(m M) { // ERROR "m does not escape"
}
// Tests for type stored directly in iface and with value receiver method.
type M0 struct {
p *int
}
func (M0) M() {
}
func efaceEscape0() {
{
i := 0
v := M0{&i}
var x M = v
_ = x
}
{
i := 0 // ERROR "moved to heap: i"
v := M0{&i}
var x M = v
sink = x
}
{
i := 0
v := M0{&i}
var x M = v
v1 := x.(M0)
_ = v1
}
{
i := 0 // ERROR "moved to heap: i"
v := M0{&i}
// BAD: v does not escape to heap here
var x M = v
v1 := x.(M0)
sink = v1
}
{
i := 0 // ERROR "moved to heap: i"
v := M0{&i}
// BAD: v does not escape to heap here
var x M = v
x.M()
}
{
i := 0 // ERROR "moved to heap: i"
v := M0{&i}
var x M = v
mescapes(x)
}
{
i := 0
v := M0{&i}
var x M = v
mdoesnotescape(x)
}
}
// Tests for type stored indirectly in iface and with value receiver method.
type M1 struct {
p *int
x int
}
func (M1) M() {
}
func efaceEscape1() {
{
i := 0
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}
var x M = v // ERROR "v escapes to heap"
sink = x
}
{
i := 0
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}
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}
// BAD: v does not escape to heap here
var x M = v // ERROR "v escapes to heap"
x.M()
}
{
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}
var x M = v // ERROR "v does not escape"
mdoesnotescape(x)
}
}
// Tests for type stored directly in iface and with pointer receiver method.
type M2 struct {
p *int
}
func (*M2) M() {
}
func efaceEscape2() {
{
i := 0
v := &M2{&i} // ERROR "&M2 literal does not escape"
var x M = v
_ = x
}
{
i := 0 // ERROR "moved to heap: i"
v := &M2{&i} // ERROR "&M2 literal escapes to heap"
var x M = v
sink = x
}
{
i := 0
v := &M2{&i} // ERROR "&M2 literal does not escape"
var x M = v
v1 := x.(*M2)
_ = v1
}
{
i := 0 // ERROR "moved to heap: i"
v := &M2{&i} // ERROR "&M2 literal escapes to heap"
// BAD: v does not escape to heap here
var x M = v
v1 := x.(*M2)
sink = v1
}
{
i := 0 // ERROR "moved to heap: i"
v := &M2{&i} // ERROR "&M2 literal does not escape"
// BAD: v does not escape to heap here
var x M = v
v1 := x.(*M2)
sink = *v1
}
{
i := 0 // ERROR "moved to heap: i"
v := &M2{&i} // ERROR "&M2 literal does not escape"
// BAD: v does not escape to heap here
var x M = v
v1, ok := x.(*M2)
sink = *v1
_ = ok
}
{
i := 0 // ERROR "moved to heap: i"
v := &M2{&i} // ERROR "&M2 literal escapes to heap"
// BAD: v does not escape to heap here
var x M = v
x.M()
}
{
i := 0 // ERROR "moved to heap: i"
v := &M2{&i} // ERROR "&M2 literal escapes to heap"
var x M = v
mescapes(x)
}
{
i := 0
v := &M2{&i} // ERROR "&M2 literal does not escape"
var x M = v
mdoesnotescape(x)
}
}
type T1 struct {
p *int
}
type T2 struct {
T1 T1
}
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{ // ERROR "&T2 literal 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)
}
{
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)
}
{
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)
}
}