mirror of
https://github.com/golang/go
synced 2024-11-19 10:04:56 -07:00
4da31df1c8
We now use LookupFieldOrMethod for all SelectorExprs, and
simplify the logic to discriminate the various cases.
We inline static calls to promoted/indirected functions,
dramatically reducing the number of functions created.
More tests are needed, but I'd like to submit this as-is.
In this CL, we:
- rely less on Id strings. Internally we now use
*types.Method (and its components) almost everywhere.
- stop thinking of types.Methods as objects. They don't
have stable identities. (Hopefully they will become
plain-old structs soon.)
- eliminate receiver indirection wrappers:
indirection and promotion are handled together by makeWrapper.
- Handle the interactions of promotion, indirection and
abstract methods much more cleanly.
- support receiver-bound interface method closures.
- break up builder.selectField so we can re-use parts
(emitFieldSelection).
- add importer.PackageInfo.classifySelector utility.
- delete interfaceMethodIndex()
- delete namedTypeMethodIndex()
- delete isSuperInterface() (replaced by types.IsAssignable)
- call memberFromObject on each declared concrete method's
*types.Func, not on every Method frem each method set, in the
CREATE phase for packages loaded by gcimporter.
go/types:
- document Func, Signature.Recv() better.
- use fmt in {Package,Label}.String
- reimplement Func.String to be prettier and to include method
receivers.
API changes:
- Function.method now holds the types.Method (soon to be
not-an-object) for synthetic wrappers.
- CallCommon.Method now contains an abstract (interface)
method object; was an abstract method index.
- CallCommon.MethodId() gone.
- Program.LookupMethod now takes a *Method not an Id string.
R=gri
CC=golang-dev
https://golang.org/cl/11674043
115 lines
1.5 KiB
Go
115 lines
1.5 KiB
Go
// Tests of bound method closures.
|
|
|
|
package main
|
|
|
|
func assert(b bool) {
|
|
if !b {
|
|
panic("oops")
|
|
}
|
|
}
|
|
|
|
type I int
|
|
|
|
func (i I) add(x int) int {
|
|
return int(i) + x
|
|
}
|
|
|
|
func valueReceiver() {
|
|
var three I = 3
|
|
assert(three.add(5) == 8)
|
|
var add3 func(int) int = three.add
|
|
assert(add3(5) == 8)
|
|
}
|
|
|
|
type S struct{ x int }
|
|
|
|
func (s *S) incr() {
|
|
s.x++
|
|
}
|
|
|
|
func (s *S) get() int {
|
|
return s.x
|
|
}
|
|
|
|
func pointerReceiver() {
|
|
ps := new(S)
|
|
incr := ps.incr
|
|
get := ps.get
|
|
assert(get() == 0)
|
|
incr()
|
|
incr()
|
|
incr()
|
|
assert(get() == 3)
|
|
}
|
|
|
|
func addressibleValuePointerReceiver() {
|
|
var s S
|
|
incr := s.incr
|
|
get := s.get
|
|
assert(get() == 0)
|
|
incr()
|
|
incr()
|
|
incr()
|
|
assert(get() == 3)
|
|
}
|
|
|
|
type S2 struct {
|
|
S
|
|
}
|
|
|
|
func promotedReceiver() {
|
|
var s2 S2
|
|
incr := s2.incr
|
|
get := s2.get
|
|
assert(get() == 0)
|
|
incr()
|
|
incr()
|
|
incr()
|
|
assert(get() == 3)
|
|
}
|
|
|
|
func anonStruct() {
|
|
var s struct{ S }
|
|
incr := s.incr
|
|
get := s.get
|
|
assert(get() == 0)
|
|
incr()
|
|
incr()
|
|
incr()
|
|
assert(get() == 3)
|
|
}
|
|
|
|
func typeCheck() {
|
|
var i interface{}
|
|
i = (*S).incr
|
|
_ = i.(func(*S)) // type assertion: receiver type prepended to params
|
|
|
|
var s S
|
|
i = s.incr
|
|
_ = i.(func()) // type assertion: receiver type disappears
|
|
}
|
|
|
|
type errString string
|
|
|
|
func (err errString) Error() string {
|
|
return string(err)
|
|
}
|
|
|
|
// Regression test for a builder crash.
|
|
func regress1(x error) func() string {
|
|
return x.Error
|
|
}
|
|
|
|
func main() {
|
|
valueReceiver()
|
|
pointerReceiver()
|
|
addressibleValuePointerReceiver()
|
|
promotedReceiver()
|
|
anonStruct()
|
|
typeCheck()
|
|
|
|
if e := regress1(errString("hi"))(); e != "hi" {
|
|
panic(e)
|
|
}
|
|
}
|