mirror of
https://github.com/golang/go
synced 2024-09-06 00:19:45 +00:00
![Matthew Dempsky](/assets/img/avatar_default.png)
Currently, typecheck leaves arguments to OPANIC as their original type. This CL changes it to insert implicit OCONVIFACE operations to convert arguments to `interface{}` like how any other function call would be handled. No immediate benefits, other than getting to remove a tiny bit of special-case logic in order.go's handling of OPANICs. Instead, the generic code path for handling OCONVIFACE is used, if necessary. Longer term, this should be marginally helpful for #43753, as it reduces the number of cases where we need values to be addressable for runtime calls. However, this does require adding some hacks to appease existing tests: 1. We need yet another kludge in inline budgeting, to ensure that reflect.flag.mustBe stays inlinable for cmd/compile/internal/test's TestIntendedInlining. 2. Since the OCONVIFACE expressions are now being introduced during typecheck, they're now visible to escape analysis. So expressions like "panic(1)" are now seen as "panic(interface{}(1))", and escape analysis warns that the "interface{}(1)" escapes to the heap. These have always escaped to heap, just now we're accurately reporting about it. (Also, unfortunately fmt.go hides implicit conversions by default in diagnostics messages, so instead of reporting "interface{}(1) escapes to heap", it actually reports "1 escapes to heap", which is confusing. However, this confusing messaging also isn't new.) Change-Id: Icedf60e1d2e464e219441b8d1233a313770272af Reviewed-on: https://go-review.googlesource.com/c/go/+/284412 Run-TryBot: Matthew Dempsky <mdempsky@google.com> TryBot-Result: Go Bot <gobot@golang.org> Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com> Trust: Matthew Dempsky <mdempsky@google.com>
58 lines
1.3 KiB
Go
58 lines
1.3 KiB
Go
// errorcheck -0 -m
|
|
|
|
// 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.
|
|
|
|
// Test, using compiler diagnostic flags, that the escape analysis is working.
|
|
// Compiles but does not run. Inlining is enabled.
|
|
|
|
package foo
|
|
|
|
var p *int
|
|
|
|
func alloc(x int) *int { // ERROR "can inline alloc" "moved to heap: x"
|
|
return &x
|
|
}
|
|
|
|
var f func()
|
|
|
|
func f1() {
|
|
p = alloc(2) // ERROR "inlining call to alloc" "moved to heap: x"
|
|
|
|
// Escape analysis used to miss inlined code in closures.
|
|
|
|
func() { // ERROR "can inline f1.func1"
|
|
p = alloc(3) // ERROR "inlining call to alloc"
|
|
}() // ERROR "inlining call to f1.func1" "inlining call to alloc" "moved to heap: x"
|
|
|
|
f = func() { // ERROR "func literal escapes to heap" "can inline f1.func2"
|
|
p = alloc(3) // ERROR "inlining call to alloc" "moved to heap: x"
|
|
}
|
|
f()
|
|
}
|
|
|
|
func f2() {} // ERROR "can inline f2"
|
|
|
|
// No inline for recover; panic now allowed to inline.
|
|
func f3() { panic(1) } // ERROR "can inline f3" "1 escapes to heap"
|
|
func f4() { recover() }
|
|
|
|
func f5() *byte {
|
|
type T struct {
|
|
x [1]byte
|
|
}
|
|
t := new(T) // ERROR "new.T. escapes to heap"
|
|
return &t.x[0]
|
|
}
|
|
|
|
func f6() *byte {
|
|
type T struct {
|
|
x struct {
|
|
y byte
|
|
}
|
|
}
|
|
t := new(T) // ERROR "new.T. escapes to heap"
|
|
return &t.x.y
|
|
}
|