1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
|
package vm
import "reflect"
// Runtime type and value representations (based on reflect).
// Type is the representation of a runtime type.
type Type struct {
Name string
Rtype reflect.Type
}
func (t *Type) Elem() *Type {
return &Type{Rtype: t.Rtype.Elem()}
}
func (t *Type) Out(i int) *Type {
return &Type{Rtype: t.Rtype.Out(i)}
}
// Value is the representation of a runtime value.
type Value struct {
Type *Type
Data reflect.Value
}
// NewValue returns an addressable zero value for the specified type.
func NewValue(typ *Type) Value {
return Value{Type: typ, Data: reflect.New(typ.Rtype).Elem()}
}
// TypeOf returns the runtime type of v.
func TypeOf(v any) *Type {
t := reflect.TypeOf(v)
return &Type{Name: t.Name(), Rtype: t}
}
// ValueOf returns the runtime value of v.
func ValueOf(v any) Value {
return Value{Data: reflect.ValueOf(v)}
}
func PointerTo(t *Type) *Type {
return &Type{Rtype: reflect.PointerTo(t.Rtype)}
}
func ArrayOf(size int, t *Type) *Type {
return &Type{Rtype: reflect.ArrayOf(size, t.Rtype)}
}
func SliceOf(t *Type) *Type {
return &Type{Rtype: reflect.SliceOf(t.Rtype)}
}
func FuncOf(arg, ret []*Type, variadic bool) *Type {
a := make([]reflect.Type, len(arg))
for i, e := range arg {
a[i] = e.Rtype
}
r := make([]reflect.Type, len(ret))
for i, e := range ret {
r[i] = e.Rtype
}
return &Type{Rtype: reflect.FuncOf(a, r, variadic)}
}
func StructOf(fields []*Type) *Type {
rf := make([]reflect.StructField, len(fields))
for i, f := range fields {
rf[i].Name = "X" + f.Name
rf[i].Type = f.Rtype
}
return &Type{Rtype: reflect.StructOf(rf)}
}
|
