Add better support for methods and string comparison

Author: antonmedv

checker/checker.go

@@ -155,6 +155,9 @@ func (v *visitor) BinaryNode(node *ast.BinaryNode) reflect.Type {
 		if (isFloat(l) && isIntegerNode(node.Right)) || (isIntegerNode(node.Left) && isFloat(r)) {
 			return boolType
 		}
+		if isString(l) && isString(r) {
+			return boolType
+		}
 
 	case "or", "||", "and", "&&":
 		if (isBool(l) || isInterface(l)) && (isBool(r) || isInterface(r)) {
@@ -179,6 +182,9 @@ func (v *visitor) BinaryNode(node *ast.BinaryNode) reflect.Type {
 		if (isFloat(l) && isIntegerNode(node.Right)) || (isIntegerNode(node.Left) && isFloat(r)) {
 			return boolType
 		}
+		if isString(l) && isString(r) {
+			return boolType
+		}
 
 	case "/", "-", "*", "**":
 		if (isInteger(l) || isInterface(l)) && (isInteger(r) || isInterface(r)) {

checker/checker_test.go

@@ -8,6 +8,7 @@ import (
 	"regexp"
 	"strings"
 	"testing"
+	"time"
 )
 
 func TestVisitor_FunctionNode(t *testing.T) {
@@ -31,7 +32,12 @@ func TestVisitor_MethodNode(t *testing.T) {
 	var err error
 
 	env := &mockEnv{}
-	input := `Var.Set(1, 0.5) + Var.Add(2) + Var.Any(true) + Var.Get() + Var.Sub(3)`
+	input := `Var.Set(1, 0.5) 
+				+ Var.Add(2) 
+				+ Var.Any(true) 
+				+ Var.Get() 
+				+ Var.Sub(3)
+				+ (Duration.String() == "" ? 1 : 0)`
 
 	tree, err := parser.Parse(input)
 	assert.NoError(t, err)
@@ -65,10 +71,11 @@ func TestVisitor_BuiltinNode(t *testing.T) {
 
 type mockEnv struct {
 	*mockEmbed
-	Add     func(int64) int64
-	Any     interface{}
-	Var     *mockVar
-	Tickets []mockTicket
+	Add      func(int64) int64
+	Any      interface{}
+	Var      *mockVar
+	Tickets  []mockTicket
+	Duration time.Duration
 }
 
 func (f *mockEnv) Set(v int64, any interface{}) int64 {
@@ -163,6 +170,7 @@ func TestCheck(t *testing.T) {
 		"Foo.Fn() or Foo.Fn()",
 		"Method(Foo.Bar) > 1",
 		"Embedded.Method() + Str",
+		`"a" < "b"`,
 	}
 	for _, test := range typeTests {
 		var err error

checker/types.go

@@ -182,6 +182,15 @@ func fieldType(ntype reflect.Type, name string) (reflect.Type, bool) {
 
 func methodType(t reflect.Type, name string) (reflect.Type, bool, bool) {
 	if t != nil {
+		// First, check methods defined on type itself,
+		// independent of which type it is.
+		for i := 0; i < t.NumMethod(); i++ {
+			m := t.Method(i)
+			if m.Name == name {
+				return m.Type, true, true
+			}
+		}
+
 		d := t
 		if t.Kind() == reflect.Ptr {
 			d = t.Elem()
@@ -191,23 +200,15 @@ func methodType(t reflect.Type, name string) (reflect.Type, bool, bool) {
 		case reflect.Interface:
 			return interfaceType, false, true
 		case reflect.Struct:
-			// First check all struct's methods.
-			for i := 0; i < t.NumMethod(); i++ {
-				m := t.Method(i)
-				if m.Name == name {
-					return m.Type, true, true
-				}
-			}
-
-			// Second check all struct's fields.
+			// First, check all struct's fields.
 			for i := 0; i < d.NumField(); i++ {
 				f := d.Field(i)
 				if !f.Anonymous && f.Name == name {
 					return f.Type, false, true
 				}
 			}
 
-			// Third check fields of embedded structs.
+			// Second, check fields of embedded structs.
 			for i := 0; i < d.NumField(); i++ {
 				f := d.Field(i)
 				if f.Anonymous {

vm/runtime.go

@@ -48,6 +48,15 @@ func fetch(from interface{}, i interface{}) interface{} {
 
 func fetchFn(from interface{}, name string) reflect.Value {
 	v := reflect.ValueOf(from)
+
+	// Methods can be defined on any type.
+	if v.NumMethod() > 0 {
+		method := v.MethodByName(name)
+		if method.IsValid() {
+			return method
+		}
+	}
+
 	d := v
 	if v.Kind() == reflect.Ptr {
 		d = v.Elem()
@@ -59,19 +68,7 @@ func fetchFn(from interface{}, name string) reflect.Value {
 		if value.IsValid() && value.CanInterface() {
 			return value.Elem()
 		}
-		// A map may have method too.
-		if v.NumMethod() > 0 {
-			method := v.MethodByName(name)
-			if method.IsValid() {
-				return method
-			}
-		}
 	case reflect.Struct:
-		method := v.MethodByName(name)
-		if method.IsValid() {
-			return method
-		}
-
 		// If struct has not method, maybe it has func field.
 		// To access this field we need dereference value.
 		value := d.FieldByName(name)
@@ -222,6 +219,9 @@ func equal(a, b interface{}) bool {
 	case uint64:
 		return x == uint64(cast(b))
 
+	case string:
+		return x == b.(string)
+
 	default:
 		return reflect.DeepEqual(a, b)
 	}
@@ -271,6 +271,9 @@ func less(a, b interface{}) interface{} {
 	case uint64:
 		return x < uint64(cast(b))
 
+	case string:
+		return x < b.(string)
+
 	default:
 		panic(fmt.Sprintf("invalid operation: %T < %T", a, b))
 	}
@@ -320,6 +323,9 @@ func more(a, b interface{}) interface{} {
 	case uint64:
 		return x > uint64(cast(b))
 
+	case string:
+		return x > b.(string)
+
 	default:
 		panic(fmt.Sprintf("invalid operation: %T > %T", a, b))
 	}
@@ -369,6 +375,9 @@ func lessOrEqual(a, b interface{}) interface{} {
 	case uint64:
 		return x <= uint64(cast(b))
 
+	case string:
+		return x <= b.(string)
+
 	default:
 		panic(fmt.Sprintf("invalid operation: %T <= %T", a, b))
 	}
@@ -418,6 +427,9 @@ func moreOrEqual(a, b interface{}) interface{} {
 	case uint64:
 		return x >= uint64(cast(b))
 
+	case string:
+		return x >= b.(string)
+
 	default:
 		panic(fmt.Sprintf("invalid operation: %T >= %T", a, b))
 	}

vm/vm_test.go

@@ -9,15 +9,16 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"testing"
+	"time"
 )
 
 func TestRun_debug(t *testing.T) {
 	var test = struct {
 		input  string
 		output interface{}
 	}{
-		`filter([1,2,3], {# > 2})`,
-		[]interface{}{int64(3)},
+		`Now.Sub(BirthDay).String() != Duration("1h").String()`,
+		true,
 	}
 
 	env := &mockEnv{}
@@ -211,6 +212,18 @@ func TestRun(t *testing.T) {
 			`one([1,1,0,1], {# == 0}) and not one([1,0,0,1], {# == 0})`,
 			true,
 		},
+		{
+			`Now.After(BirthDay)`,
+			true,
+		},
+		{
+			`"a" < "b"`,
+			true,
+		},
+		{
+			`Now.Sub(Now).String() == Duration("0s").String()`,
+			true,
+		},
 	}
 
 	env := &mockEnv{
@@ -226,6 +239,8 @@ func TestRun(t *testing.T) {
 		Ticket: &mockTicket{
 			Price: 100,
 		},
+		BirthDay: time.Date(2017, time.October, 23, 18, 30, 0, 0, time.UTC),
+		Now:      time.Now(),
 	}
 
 	for _, test := range tests {
@@ -246,16 +261,18 @@ func TestRun(t *testing.T) {
 }
 
 type mockEnv struct {
-	Any     interface{}
-	Int     int
-	Int32   int32
-	Int64   int64
-	Uint64  uint64
-	Float64 float64
-	Bool    bool
-	String  string
-	Array   []int
-	Ticket  *mockTicket
+	Any      interface{}
+	Int      int
+	Int32    int32
+	Int64    int64
+	Uint64   uint64
+	Float64  float64
+	Bool     bool
+	String   string
+	Array    []int
+	Ticket   *mockTicket
+	BirthDay time.Time
+	Now      time.Time
 }
 
 func (e *mockEnv) GetInt() int {
@@ -266,6 +283,14 @@ func (*mockEnv) Add(a, b int64) int {
 	return int(a + b)
 }
 
+func (*mockEnv) Duration(s string) time.Duration {
+	d, err := time.ParseDuration(s)
+	if err != nil {
+		panic(err)
+	}
+	return d
+}
+
 type mockTicket struct {
 	Price int
 }