mirror of
https://github.com/golang/go
synced 2024-11-19 06:14:39 -07:00
94c387c610
The implementation follows the basic pattern of an indirect
function call (genDynamicCall).
We use the same trick as SetFinalizer so that direct calls to
(r.V).Call, which are overwhelmingly the norm, are inlined.
Bug fix (and simplification): calling untag() to unbox a
reflect.Value is wrong for reflect.Values containing interfaces
(rare). Now, we call untag for concrete types and typeFilter
for interface types, and we can use this pattern in all cases.
It corresponds to the ssa.TypeAssert operator, so we call
it typeAssert. Added tests to cover this.
We also specialize reflect.{In,Out} when the operand is an int
literal.
+ Tests.
Also:
- make taggedValue() panic, not return nil, eliminating many checks.
We call isTaggedValue for the one place that cares.
- pointer_test: recover from panics in Analyze() and dump the log.
R=crawshaw
CC=golang-dev
https://golang.org/cl/14426050
86 lines
2.5 KiB
Go
86 lines
2.5 KiB
Go
// +build ignore
|
|
|
|
package main
|
|
|
|
import "reflect"
|
|
|
|
// Test of channels with reflection.
|
|
|
|
var a, b int
|
|
|
|
func chanreflect1() {
|
|
ch := make(chan *int, 0) // @line cr1make
|
|
crv := reflect.ValueOf(ch)
|
|
crv.Send(reflect.ValueOf(&a))
|
|
print(crv.Interface()) // @types chan *int
|
|
print(crv.Interface().(chan *int)) // @pointsto makechan@cr1make:12
|
|
print(<-ch) // @pointsto main.a
|
|
}
|
|
|
|
func chanreflect1i() {
|
|
// Exercises reflect.Value conversions to/from interfaces:
|
|
// a different code path than for concrete types.
|
|
ch := make(chan interface{}, 0)
|
|
reflect.ValueOf(ch).Send(reflect.ValueOf(&a))
|
|
v := <-ch
|
|
print(v) // @types *int
|
|
print(v.(*int)) // @pointsto main.a
|
|
}
|
|
|
|
func chanreflect2() {
|
|
ch := make(chan *int, 0)
|
|
ch <- &b
|
|
crv := reflect.ValueOf(ch)
|
|
r, _ := crv.Recv()
|
|
print(r.Interface()) // @types *int
|
|
print(r.Interface().(*int)) // @pointsto main.b
|
|
}
|
|
|
|
func chanOfRecv() {
|
|
// MakeChan(<-chan) is a no-op.
|
|
t := reflect.ChanOf(reflect.RecvDir, reflect.TypeOf(&a))
|
|
print(reflect.Zero(t).Interface()) // @types <-chan *int
|
|
print(reflect.MakeChan(t, 0).Interface().(<-chan *int)) // @pointsto
|
|
print(reflect.MakeChan(t, 0).Interface().(chan *int)) // @pointsto
|
|
}
|
|
|
|
func chanOfSend() {
|
|
// MakeChan(chan<-) is a no-op.
|
|
t := reflect.ChanOf(reflect.SendDir, reflect.TypeOf(&a))
|
|
print(reflect.Zero(t).Interface()) // @types chan<- *int
|
|
print(reflect.MakeChan(t, 0).Interface().(chan<- *int)) // @pointsto
|
|
print(reflect.MakeChan(t, 0).Interface().(chan *int)) // @pointsto
|
|
}
|
|
|
|
func chanOfBoth() {
|
|
t := reflect.ChanOf(reflect.BothDir, reflect.TypeOf(&a))
|
|
print(reflect.Zero(t).Interface()) // @types chan *int
|
|
ch := reflect.MakeChan(t, 0)
|
|
print(ch.Interface().(chan *int)) // @pointsto <alloc in reflect.MakeChan>
|
|
ch.Send(reflect.ValueOf(&b))
|
|
ch.Interface().(chan *int) <- &a
|
|
r, _ := ch.Recv()
|
|
print(r.Interface().(*int)) // @pointsto main.a | main.b
|
|
print(<-ch.Interface().(chan *int)) // @pointsto main.a | main.b
|
|
}
|
|
|
|
var unknownDir reflect.ChanDir // not a constant
|
|
|
|
func chanOfUnknown() {
|
|
// Unknown channel direction: assume all three.
|
|
// MakeChan only works on the bi-di channel type.
|
|
t := reflect.ChanOf(unknownDir, reflect.TypeOf(&a))
|
|
print(reflect.Zero(t).Interface()) // @types <-chan *int | chan<- *int | chan *int
|
|
print(reflect.MakeChan(t, 0).Interface()) // @types chan *int
|
|
}
|
|
|
|
func main() {
|
|
chanreflect1()
|
|
chanreflect1i()
|
|
chanreflect2()
|
|
chanOfRecv()
|
|
chanOfSend()
|
|
chanOfBoth()
|
|
chanOfUnknown()
|
|
}
|