mirror of
https://github.com/golang/go
synced 2024-11-14 14:10:29 -07:00
688995d1e9
The code to do the conversion is smaller than the
call to the runtime.
The 1-result asserts need to call panic if they fail, but that
code is out of line.
The only conversions left in the runtime are those which
might allocate and those which might need to generate an itab.
Given the following types:
type E interface{}
type I interface { foo() }
type I2 iterface { foo(); bar() }
type Big [10]int
func (b Big) foo() { ... }
This CL inlines the following conversions:
was assertE2T
var e E = ...
b := i.(Big)
was assertE2T2
var e E = ...
b, ok := i.(Big)
was assertI2T
var i I = ...
b := i.(Big)
was assertI2T2
var i I = ...
b, ok := i.(Big)
was assertI2E
var i I = ...
e := i.(E)
was assertI2E2
var i I = ...
e, ok := i.(E)
These are the remaining runtime calls:
convT2E:
var b Big = ...
var e E = b
convT2I:
var b Big = ...
var i I = b
convI2I:
var i2 I2 = ...
var i I = i2
assertE2I:
var e E = ...
i := e.(I)
assertE2I2:
var e E = ...
i, ok := e.(I)
assertI2I:
var i I = ...
i2 := i.(I2)
assertI2I2:
var i I = ...
i2, ok := i.(I2)
Fixes #17405
Fixes #8422
Change-Id: Ida2367bf8ce3cd2c6bb599a1814f1d275afabe21
Reviewed-on: https://go-review.googlesource.com/32313
Run-TryBot: Keith Randall <khr@golang.org>
Reviewed-by: David Chase <drchase@google.com>
75 lines
1.8 KiB
Go
75 lines
1.8 KiB
Go
// errorcheck -0 -d=typeassert
|
|
|
|
// 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.
|
|
|
|
package p
|
|
|
|
func assertptr(x interface{}) *int {
|
|
return x.(*int) // ERROR "type assertion inlined"
|
|
}
|
|
|
|
func assertptr2(x interface{}) (*int, bool) {
|
|
z, ok := x.(*int) // ERROR "type assertion inlined"
|
|
return z, ok
|
|
}
|
|
|
|
func assertfunc(x interface{}) func() {
|
|
return x.(func()) // ERROR "type assertion inlined"
|
|
}
|
|
|
|
func assertfunc2(x interface{}) (func(), bool) {
|
|
z, ok := x.(func()) // ERROR "type assertion inlined"
|
|
return z, ok
|
|
}
|
|
|
|
func assertstruct(x interface{}) struct{ *int } {
|
|
return x.(struct{ *int }) // ERROR "type assertion inlined"
|
|
}
|
|
|
|
func assertstruct2(x interface{}) (struct{ *int }, bool) {
|
|
z, ok := x.(struct{ *int }) // ERROR "type assertion inlined"
|
|
return z, ok
|
|
}
|
|
|
|
func assertbig(x interface{}) complex128 {
|
|
return x.(complex128) // ERROR "type assertion inlined"
|
|
}
|
|
|
|
func assertbig2(x interface{}) (complex128, bool) {
|
|
z, ok := x.(complex128) // ERROR "type assertion inlined"
|
|
return z, ok
|
|
}
|
|
|
|
func assertbig2ok(x interface{}) (complex128, bool) {
|
|
_, ok := x.(complex128) // ERROR "type assertion inlined"
|
|
return 0, ok
|
|
}
|
|
|
|
func assertslice(x interface{}) []int {
|
|
return x.([]int) // ERROR "type assertion inlined"
|
|
}
|
|
|
|
func assertslice2(x interface{}) ([]int, bool) {
|
|
z, ok := x.([]int) // ERROR "type assertion inlined"
|
|
return z, ok
|
|
}
|
|
|
|
func assertslice2ok(x interface{}) ([]int, bool) {
|
|
_, ok := x.([]int) // ERROR "type assertion inlined"
|
|
return nil, ok
|
|
}
|
|
|
|
type I interface {
|
|
foo()
|
|
}
|
|
|
|
func assertInter(x interface{}) I {
|
|
return x.(I) // ERROR "type assertion not inlined"
|
|
}
|
|
func assertInter2(x interface{}) (I, bool) {
|
|
z, ok := x.(I) // ERROR "type assertion not inlined"
|
|
return z, ok
|
|
}
|