Add support for struct's methods, improve ~ operator types, fix ?: operator return type

Author: antonmedv

eval.go

@@ -268,7 +268,7 @@ func (n methodNode) Eval(env interface{}) (interface{}, error) {
 		return nil, err
 	}
 
-	method, ok := extract(v, n.method)
+	method, ok := getFunc(v, n.method)
 	if !ok {
 		return nil, fmt.Errorf("cannot get method %v from %T: %v", n.method, v, n)
 	}
@@ -324,7 +324,7 @@ func (n builtinNode) Eval(env interface{}) (interface{}, error) {
 }
 
 func (n functionNode) Eval(env interface{}) (interface{}, error) {
-	fn, ok := extract(env, n.name)
+	fn, ok := getFunc(env, n.name)
 	if !ok {
 		return nil, fmt.Errorf("undefined: %v", n.name)
 	}

eval_test.go

@@ -564,7 +564,7 @@ func TestEval_complex(t *testing.T) {
 
 	expected := true
 	if !reflect.DeepEqual(actual, expected) {
-		t.Fatalf("TestEvalComplex:\ngot\n\t%#v\nexpected:\n\t%#v", actual, expected)
+		t.Fatalf("TestEval_complex:\ngot\n\t%#v\nexpected:\n\t%#v", actual, expected)
 	}
 }
 
@@ -584,3 +584,59 @@ func TestEval_panic(t *testing.T) {
 		t.Errorf("\ngot\n\t%+v\nexpected\n\t%v", err.Error(), expected)
 	}
 }
+
+func TestEval_method(t *testing.T) {
+	env := testEnv{
+		Hello: "hello",
+		World: testWorld{
+			name: []string{"w", "o", "r", "l", "d"},
+		},
+		testVersion: testVersion{
+			version: 2,
+		},
+	}
+
+	input := `Title(Hello) ~ ' ' ~ (CompareVersion(1, 3) ? World.String() : '')`
+
+	node, err := expr.Parse(input)
+	fmt.Printf("%#v\n", node)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	actual, err := expr.Run(node, env)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	expected := "Hello world"
+	if !reflect.DeepEqual(actual, expected) {
+		t.Fatalf("TestEval_method:\ngot\n\t%#v\nexpected:\n\t%#v", actual, expected)
+	}
+}
+
+type testVersion struct {
+	version float64
+}
+
+func (c testVersion) CompareVersion(min, max float64) bool {
+	return min < c.version && c.version < max
+}
+
+type testWorld struct {
+	name []string
+}
+
+func (w testWorld) String() string {
+	return strings.Join(w.name, "")
+}
+
+type testEnv struct {
+	testVersion
+	Hello string
+	World testWorld
+}
+
+func (e testEnv) Title(s string) string {
+	return strings.Title(s)
+}

parser.go

@@ -181,6 +181,11 @@ func (p *parser) fromStruct(t reflect.Type) typesTable {
 
 			types[f.Name] = f.Type
 		}
+
+		for i := 0; i < t.NumMethod(); i++ {
+			m := t.Method(i)
+			types[m.Name] = m.Type
+		}
 	}
 
 	return types

runtime.go

@@ -101,6 +101,33 @@ func extract(val interface{}, i interface{}) (interface{}, bool) {
 	return nil, false
 }
 
+func getFunc(val interface{}, i interface{}) (interface{}, bool) {
+	v := reflect.ValueOf(val)
+	switch v.Kind() {
+	case reflect.Map:
+		value := v.MapIndex(reflect.ValueOf(i))
+		if value.IsValid() && value.CanInterface() {
+			return value.Interface(), true
+		}
+	case reflect.Struct:
+		name := reflect.ValueOf(i).String()
+		method := v.MethodByName(name)
+		if method.IsValid() && method.CanInterface() {
+			return method.Interface(), true
+		}
+		value := v.FieldByName(name)
+		if value.IsValid() && value.CanInterface() {
+			return value.Interface(), true
+		}
+	case reflect.Ptr:
+		value := v.Elem()
+		if value.IsValid() && value.CanInterface() {
+			return getFunc(value.Interface(), i)
+		}
+	}
+	return nil, false
+}
+
 func contains(needle interface{}, array interface{}) (bool, error) {
 	if array != nil {
 		v := reflect.ValueOf(array)

type.go

@@ -115,6 +115,12 @@ func (n binaryNode) Type(table typesTable) (Type, error) {
 		}
 		return nil, fmt.Errorf(`invalid operation: %v (mismatched types %v and %v)`, n, ltype, rtype)
 
+	case "~":
+		if (isStringType(ltype) || isInterfaceType(ltype)) && (isStringType(rtype) || isInterfaceType(rtype)) {
+			return textType, nil
+		}
+		return nil, fmt.Errorf(`invalid operation: %v (mismatched types %v and %v)`, n, ltype, rtype)
+
 	}
 
 	return interfaceType, nil
@@ -173,7 +179,7 @@ func (n methodNode) Type(table typesTable) (Type, error) {
 			return nil, err
 		}
 	}
-	if t, ok := fieldType(ntype, n.method); ok {
+	if t, ok := methodType(ntype, n.method); ok {
 		if f, ok := funcType(t); ok {
 			return f, nil
 		}
@@ -220,15 +226,29 @@ func (n conditionalNode) Type(table typesTable) (Type, error) {
 	if !isBoolType(ctype) && !isInterfaceType(ctype) {
 		return nil, fmt.Errorf("non-bool %v (type %v) used as condition", n.cond, ctype)
 	}
-	_, err = n.exp1.Type(table)
+
+	t1, err := n.exp1.Type(table)
 	if err != nil {
 		return nil, err
 	}
-	_, err = n.exp2.Type(table)
+	t2, err := n.exp2.Type(table)
 	if err != nil {
 		return nil, err
 	}
-	return boolType, nil
+
+	if t1 == nil && t2 != nil {
+		return t2, nil
+	}
+	if t1 != nil && t2 == nil {
+		return t1, nil
+	}
+	if t1 == nil && t2 == nil {
+		return nilType, nil
+	}
+	if t1.AssignableTo(t2) {
+		return t1, nil
+	}
+	return interfaceType, nil
 }
 
 func (n arrayNode) Type(table typesTable) (Type, error) {
@@ -399,6 +419,46 @@ func fieldType(ntype Type, name string) (Type, bool) {
 	return nil, false
 }
 
+func methodType(ntype Type, name string) (Type, bool) {
+	ntype = dereference(ntype)
+	if ntype != nil {
+		switch ntype.Kind() {
+		case reflect.Interface:
+			return interfaceType, true
+		case reflect.Struct:
+			// First check all struct's methods.
+			for i := 0; i < ntype.NumMethod(); i++ {
+				m := ntype.Method(i)
+				if m.Name == name {
+					return m.Type, true
+				}
+			}
+
+			// Second check all struct's fields.
+			for i := 0; i < ntype.NumField(); i++ {
+				f := ntype.Field(i)
+				if !f.Anonymous && f.Name == name {
+					return f.Type, true
+				}
+			}
+
+			// Third check fields of embedded structs.
+			for i := 0; i < ntype.NumField(); i++ {
+				f := ntype.Field(i)
+				if f.Anonymous {
+					if t, ok := methodType(f.Type, name); ok {
+						return t, true
+					}
+				}
+			}
+		case reflect.Map:
+			return ntype.Elem(), true
+		}
+	}
+
+	return nil, false
+}
+
 func indexType(ntype Type) (Type, bool) {
 	ntype = dereference(ntype)
 	if ntype == nil {

type_test.go

@@ -25,6 +25,7 @@ var typeTests = []typeTest{
 	"Fn(Any)",
 	"Foo.Fn()",
 	"true ? Any : Any",
+	"Str ~ (true ? Str : Str)",
 	"Ok && Any",
 	"Str matches 'ok'",
 	"Str matches Any",
@@ -76,11 +77,13 @@ var typeTests = []typeTest{
 	"EmbStr == ''",
 	"Embedded.EmbStr",
 	"EmbPtrStr == ''",
-	"EmbeddedPtr ~ Str",
+	"EmbeddedPtr.EmbPtrStr ~ Str",
 	"SubStr ~ ''",
 	"SubEmbedded.SubStr",
 	"OkFn() and OkFn()",
 	"Foo.Fn() or Foo.Fn()",
+	"Method() > 1",
+	"Embedded.Method() ~ Str",
 }
 
 var typeErrorTests = []typeErrorTest{
@@ -284,6 +287,10 @@ var typeErrorTests = []typeErrorTest{
 		"1 in Foo",
 		"invalid operation: 1 in Foo (mismatched types float64 and *expr_test.foo)",
 	},
+	{
+		"1 ~ ''",
+		`invalid operation: 1 ~ "" (mismatched types float64 and string)`,
+	},
 }
 
 type abc interface {
@@ -331,6 +338,14 @@ type payload struct {
 	NilFn  func()
 }
 
+func (p payload) Method() int {
+	return 0
+}
+
+func (p Embedded) Method() string {
+	return ""
+}
+
 func TestType(t *testing.T) {
 	for _, test := range typeTests {
 		_, err := expr.Parse(string(test), expr.Env(&payload{}))