mirror of
https://github.com/golang/go.git
synced 2025-05-06 16:13:04 +00:00
3371b79a96
(reflect.Value).Send
(reflect.Value).TrySend
(reflect.Value).Recv
(reflect.Value).TryRecv
(reflect.Type).ChanOf
(reflect.Type).In
(reflect.Type).Out
reflect.Indirect
reflect.MakeChan
Also:
- specialize genInvoke when the receiver is a reflect.Type under the
assumption that there's only one possible concrete type. This
makes all reflect.Type operations context-sensitive since the calls
are no longer dynamic.
- Rename all variables to match the actual parameter names used in
the reflect API.
- Add pointer.Config.Reflection flag
(exposed in oracle as --reflect, default false) to enable reflection.
It currently adds about 20% running time. I'll make it true after
the presolver is implemented.
- Simplified worklist datatype and solver main loop slightly
(~10% speed improvement).
- Use addLabel() utility to add a label to a PTS.
(Working on my 3 yr old 2x2GHz+4GB Mac vs 8x4GHz+24GB workstation,
one really notices the cost of pointer analysis.
Note to self: time to implement presolver.)
R=crawshaw
CC=golang-dev
https://golang.org/cl/13242062
80 lines
2.4 KiB
Go
80 lines
2.4 KiB
Go
// +build ignore
|
|
|
|
package main
|
|
|
|
// Test of maps with reflection.
|
|
|
|
import "reflect"
|
|
|
|
var a int
|
|
var b bool
|
|
|
|
func reflectMapKeysIndex() {
|
|
m := make(map[*int]*bool) // @line mr1make
|
|
m[&a] = &b
|
|
|
|
mrv := reflect.ValueOf(m)
|
|
print(mrv.Interface()) // @types map[*int]*bool
|
|
print(mrv.Interface().(map[*int]*bool)) // @pointsto makemap@mr1make:11
|
|
print(mrv) // @pointsto makeinterface:map[*int]*bool
|
|
print(mrv) // @types map[*int]*bool
|
|
|
|
keys := mrv.MapKeys()
|
|
print(keys) // @pointsto <alloc in (reflect.Value).MapKeys>
|
|
for _, k := range keys {
|
|
print(k) // @pointsto <alloc in (reflect.Value).MapKeys>
|
|
print(k) // @types *int
|
|
print(k.Interface()) // @types *int
|
|
print(k.Interface().(*int)) // @pointsto main.a
|
|
|
|
v := mrv.MapIndex(k)
|
|
print(v.Interface()) // @types *bool
|
|
print(v.Interface().(*bool)) // @pointsto main.b
|
|
}
|
|
}
|
|
|
|
func reflectSetMapIndex() {
|
|
m := make(map[*int]*bool)
|
|
mrv := reflect.ValueOf(m)
|
|
mrv.SetMapIndex(reflect.ValueOf(&a), reflect.ValueOf(&b))
|
|
|
|
print(m[nil]) // @pointsto main.b
|
|
|
|
for _, k := range mrv.MapKeys() {
|
|
print(k.Interface()) // @types *int
|
|
print(k.Interface().(*int)) // @pointsto main.a
|
|
}
|
|
|
|
tmap := reflect.TypeOf(m)
|
|
// types.EvalNode won't let us refer to non-exported types:
|
|
// print(tmap) // #@types *reflect.rtype
|
|
print(tmap) // @pointsto map[*int]*bool
|
|
|
|
zmap := reflect.Zero(tmap)
|
|
print(zmap) // @pointsto <alloc in reflect.Zero>
|
|
print(zmap.Interface()) // @pointsto <alloc in reflect.Zero>
|
|
|
|
print(tmap.Key()) // @pointsto *int
|
|
print(tmap.Elem()) // @pointsto *bool
|
|
print(reflect.Zero(tmap.Key())) // @pointsto <alloc in reflect.Zero>
|
|
print(reflect.Zero(tmap.Key()).Interface()) // @pointsto <alloc in reflect.Zero>
|
|
print(reflect.Zero(tmap.Key()).Interface()) // @types *int
|
|
print(reflect.Zero(tmap.Elem())) // @pointsto <alloc in reflect.Zero>
|
|
print(reflect.Zero(tmap.Elem()).Interface()) // @pointsto <alloc in reflect.Zero>
|
|
print(reflect.Zero(tmap.Elem()).Interface()) // @types *bool
|
|
}
|
|
|
|
func reflectMakeMap() {
|
|
t := reflect.TypeOf(map[*int]*bool(nil))
|
|
v := reflect.MakeMap(t)
|
|
print(v) // @types map[*int]*bool
|
|
print(v) // @pointsto <alloc in reflect.MakeMap>
|
|
}
|
|
|
|
func main() {
|
|
reflectMapKeysIndex()
|
|
reflectSetMapIndex()
|
|
reflectMakeMap()
|
|
// TODO(adonovan): reflect.MapOf(Type)
|
|
}
|