/
evalcompositelit.go
96 lines (86 loc) · 2.39 KB
/
evalcompositelit.go
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
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
package eval
import (
"errors"
"fmt"
"reflect"
)
func evalCompositeLit(ctx *Ctx, lit *CompositeLit, env *Env) (reflect.Value, error) {
t := lit.KnownType()[0]
switch t.Kind() {
case reflect.Map:
return evalCompositeLitMap(ctx, t, lit, env)
case reflect.Array, reflect.Slice:
return evalCompositeLitArrayOrSlice(ctx, t, lit, env)
case reflect.Struct:
return evalCompositeLitStruct(ctx, t, lit, env)
default:
return reflect.Value{}, errors.New(fmt.Sprintf("eval: unimplemented type for composite literal %s", t.Name()))
}
}
func evalCompositeLitMap(ctx *Ctx, t reflect.Type, lit *CompositeLit, env *Env) (reflect.Value, error) {
m := reflect.MakeMap(t)
kT := knownType{t.Key()}
vT := knownType{t.Elem()}
for _, elt := range lit.Elts {
kv := elt.(*KeyValueExpr)
k, err := evalTypedExpr(ctx, kv.Key.(Expr), kT, env)
if err != nil {
return reflect.Value{}, err
}
if kT[0].Kind() == reflect.Interface {
dynamicT := k[0].Elem().Type()
if !isStaticTypeComparable(dynamicT) {
return reflect.Value{}, PanicUnhashableType{dynamicT}
}
}
v, err := evalTypedExpr(ctx, kv.Value.(Expr), vT, env)
if err != nil {
return reflect.Value{}, err
}
m.SetMapIndex(k[0], v[0])
}
return m, nil
}
func evalCompositeLitArrayOrSlice(ctx *Ctx, t reflect.Type, lit *CompositeLit, env *Env) (reflect.Value, error) {
var v reflect.Value
if t.Kind() == reflect.Slice {
v = reflect.MakeSlice(t, lit.length, lit.length)
} else {
v = reflect.New(t).Elem()
}
eT := knownType{t.Elem()}
for src, dst, i := 0, 0, 0; src < len(lit.Elts); src, dst = src + 1, dst + 1 {
var elt Expr
if lit.indices[i].pos == src {
elt = lit.Elts[src].(*KeyValueExpr).Value.(Expr)
dst = lit.indices[i].index
i += 1
} else {
elt = lit.Elts[src].(Expr)
}
if elem, err := evalTypedExpr(ctx, elt, eT, env); err != nil {
return reflect.Value{}, err
} else {
v.Index(dst).Set(elem[0])
}
}
return v, nil
}
func evalCompositeLitStruct(ctx *Ctx, t reflect.Type, lit *CompositeLit, env *Env) (reflect.Value, error) {
v := reflect.New(t).Elem()
for i, f := range lit.fields {
var elt Expr
if kv, ok := lit.Elts[i].(*KeyValueExpr); ok {
elt = kv.Value.(Expr)
} else {
elt = lit.Elts[i].(Expr)
}
field := v.Field(f)
if elem, err := evalTypedExpr(ctx, elt, knownType{field.Type()}, env); err != nil {
return reflect.Value{}, err
} else {
field.Set(elem[0])
}
}
return v, nil
}