Refactor utils to runtime

Author: antonmedv

eval.go

@@ -50,7 +50,11 @@ func (n textNode) Eval(env interface{}) (interface{}, error) {
 }
 
 func (n nameNode) Eval(env interface{}) (interface{}, error) {
-	return extract(env, n.name)
+	v, ok := extract(env, n.name)
+	if !ok {
+		return nil, fmt.Errorf("undefined: %v", n)
+	}
+	return v, nil
 }
 
 func (n unaryNode) Eval(env interface{}) (interface{}, error) {
@@ -61,16 +65,10 @@ func (n unaryNode) Eval(env interface{}) (interface{}, error) {
 
 	switch n.operator {
 	case "not", "!":
-		if !isBool(val) {
-			return nil, fmt.Errorf("negation of non-bool type %T", val)
-		}
-		return !toBool(val), nil
+		return !toBool(n, val), nil
 	}
 
-	v, err := cast(val)
-	if err != nil {
-		return nil, err
-	}
+	v := toNumber(n, val)
 	switch n.operator {
 	case "-":
 		return -v, nil
@@ -89,40 +87,23 @@ func (n binaryNode) Eval(env interface{}) (interface{}, error) {
 
 	switch n.operator {
 	case "or", "||":
-		if !isBool(left) {
-			return nil, fmt.Errorf("non-bool value in cond (%T)", left)
-		}
-
-		if toBool(left) {
+		if toBool(n.left, left) {
 			return true, nil
 		}
-
 		right, err := n.right.Eval(env)
 		if err != nil {
 			return nil, err
 		}
-		if !isBool(right) {
-			return nil, fmt.Errorf("non-bool value in cond (%T)", right)
-		}
-
-		return toBool(right), nil
+		return toBool(n.right, right), nil
 
 	case "and", "&&":
-		if !isBool(left) {
-			return nil, fmt.Errorf("non-bool value in cond (%T)", left)
-		}
-
-		if toBool(left) {
+		if toBool(n.left, left) {
 			right, err := n.right.Eval(env)
 			if err != nil {
 				return nil, err
 			}
-			if !isBool(right) {
-				return nil, fmt.Errorf("non-bool value in cond (%T)", right)
-			}
-			return toBool(right), nil
+			return toBool(n.right, right), nil
 		}
-
 		return false, nil
 	}
 
@@ -153,23 +134,12 @@ func (n binaryNode) Eval(env interface{}) (interface{}, error) {
 		return !ok, nil
 
 	case "~":
-		if isText(left) && isText(right) {
-			return toText(left) + toText(right), nil
-		}
-		return nil, fmt.Errorf("operator ~ not defined on (%T, %T)", left, right)
+		return toText(n.left, left) + toText(n.right, right), nil
 	}
 
 	// Next goes operators on numbers
 
-	l, err := cast(left)
-	if err != nil {
-		return nil, err
-	}
-
-	r, err := cast(right)
-	if err != nil {
-		return nil, err
-	}
+	l, r := toNumber(n.left, left), toNumber(n.right, right)
 
 	switch n.operator {
 	case "|":
@@ -246,45 +216,47 @@ func (n matchesNode) Eval(env interface{}) (interface{}, error) {
 	}
 
 	if n.r != nil {
-		if isText(left) {
-			return n.r.MatchString(toText(left)), nil
-		}
+		return n.r.MatchString(toText(n.left, left)), nil
 	}
 
 	right, err := n.right.Eval(env)
 	if err != nil {
 		return nil, err
 	}
 
-	if isText(left) && isText(right) {
-		matched, err := regexp.MatchString(toText(right), toText(left))
-		if err != nil {
-			return nil, err
-		}
-		return matched, nil
+	matched, err := regexp.MatchString(toText(n.right, right), toText(n.left, left))
+	if err != nil {
+		return nil, err
 	}
-
-	return nil, fmt.Errorf("operator matches doesn't defined on (%T, %T): %v", left, right, n)
+	return matched, nil
 }
 
 func (n propertyNode) Eval(env interface{}) (interface{}, error) {
 	v, err := n.node.Eval(env)
 	if err != nil {
 		return nil, err
 	}
-	return extract(v, n.property)
+	p, ok := extract(v, n.property)
+	if !ok {
+		return nil, fmt.Errorf("%v undefined (type %T has no field %v)", n, v, n.property)
+	}
+	return p, nil
 }
 
 func (n indexNode) Eval(env interface{}) (interface{}, error) {
 	v, err := n.node.Eval(env)
 	if err != nil {
 		return nil, err
 	}
-	p, err := n.index.Eval(env)
+	i, err := n.index.Eval(env)
 	if err != nil {
 		return nil, err
 	}
-	return extract(v, p)
+	p, ok := extract(v, i)
+	if !ok {
+		return nil, fmt.Errorf("cannot get %q from %T: %v", i, v, n)
+	}
+	return p, nil
 }
 
 func (n methodNode) Eval(env interface{}) (interface{}, error) {
@@ -293,9 +265,9 @@ func (n methodNode) Eval(env interface{}) (interface{}, error) {
 		return nil, err
 	}
 
-	method, err := extract(v, n.method)
-	if err != nil {
-		return nil, err
+	method, ok := extract(v, n.method)
+	if !ok {
+		return nil, fmt.Errorf("cannot get method %v from %T: %v", n.method, v, n)
 	}
 
 	in := make([]reflect.Value, 0)
@@ -349,9 +321,9 @@ func (n builtinNode) Eval(env interface{}) (interface{}, error) {
 }
 
 func (n functionNode) Eval(env interface{}) (interface{}, error) {
-	fn, err := extract(env, n.name)
-	if err != nil {
-		return nil, err
+	fn, ok := extract(env, n.name)
+	if !ok {
+		return nil, fmt.Errorf("undefined: %v", n.name)
 	}
 
 	in := make([]reflect.Value, 0)
@@ -386,11 +358,8 @@ func (n conditionalNode) Eval(env interface{}) (interface{}, error) {
 	}
 
 	// If
-	if !isBool(cond) {
-		return nil, fmt.Errorf("non-bool value used in cond (%T)", cond)
-	}
-	// Then
-	if toBool(cond) {
+	if toBool(n.cond, cond) {
+		// Then
 		a, err := n.exp1.Eval(env)
 		if err != nil {
 			return nil, err

eval_test.go

@@ -15,6 +15,12 @@ type evalTest struct {
 	expected interface{}
 }
 
+type evalErrorTest struct {
+	input string
+	env   interface{}
+	err   string
+}
+
 var evalTests = []evalTest{
 	{
 		"foo",
@@ -315,27 +321,41 @@ var evalTests = []evalTest{
 	},
 }
 
-type evalErrorTest struct {
-	input string
-	env   interface{}
-	err   string
-}
-
 var evalErrorTests = []evalErrorTest{
 	{
 		"bar",
 		map[string]int{"foo": 1},
-		`can't get "bar"`,
+		`undefined: bar`,
 	},
 	{
-		`"foo" ~ nil`,
+		`"foo" ~ foo`,
+		map[string]*int{"foo": nil},
+		`cannot convert foo (type *int) to type string`,
+	},
+	{
+		"1 or 0",
+		nil,
+		"cannot convert 1 (type float64) to type bool",
+	},
+	{
+		"not nil",
+		nil,
+		"cannot convert not nil (type <nil>) to type bool",
+	},
+	{
+		"nil matches 'nil'",
 		nil,
-		`operator ~ not defined on (string, <nil>)`,
+		"cannot convert nil (type <nil>) to type string",
 	},
 	{
 		"foo['bar'].baz",
 		map[string]interface{}{"foo": nil},
-		`can't get "bar" from <nil>`,
+		`cannot get "bar" from <nil>: foo["bar"]`,
+	},
+	{
+		"foo.bar(abc)",
+		map[string]interface{}{"foo": nil},
+		`cannot get method bar from <nil>: foo.bar(abc)`,
 	},
 	{
 		`"seafood" matches "a(b"`,
@@ -350,22 +370,22 @@ var evalErrorTests = []evalErrorTest{
 	{
 		`1 matches "1" ~ "2"`,
 		nil,
-		"operator matches doesn't defined on (float64, string): (1 matches \"1\" ~ \"2\")",
+		"cannot convert 1 (type float64) to type string",
 	},
 	{
 		`1 matches "1"`,
 		nil,
-		"operator matches doesn't defined on (float64, string): (1 matches \"1\")",
+		"cannot convert 1 (type float64) to type string",
 	},
 	{
 		`"1" matches 1`,
 		nil,
-		"operator matches doesn't defined on (string, float64): (\"1\" matches 1)",
+		"cannot convert 1 (type float64) to type string",
 	},
 	{
-		`0 ? 1 : 2`,
-		nil,
-		`non-bool value used in cond`,
+		`foo ? 1 : 2`,
+		map[string]interface{}{"foo": 0},
+		`cannot convert foo (type int) to type bool`,
 	},
 	{
 		`foo()`,
@@ -395,22 +415,22 @@ var evalErrorTests = []evalErrorTest{
 	{
 		"1 + 'a'",
 		nil,
-		"can't cast string to float64",
+		`cannot convert "a" (type string) to type float64`,
 	},
 	{
 		"'a' + 1",
 		nil,
-		"can't cast string to float64",
+		`cannot convert "a" (type string) to type float64`,
 	},
 	{
 		"[1, 2]['a']",
 		nil,
-		"can't cast string to float64",
+		`cannot get "a" from []interface {}: [1, 2]["a"]`,
 	},
 	{
 		`1 in "a"`,
 		nil,
-		"operator in not defined on string",
+		`operator "in" not defined on string`,
 	},
 	{
 		"len()",
@@ -444,9 +464,9 @@ func TestEval(t *testing.T) {
 
 func TestEval_error(t *testing.T) {
 	for _, test := range evalErrorTests {
-		_, err := expr.Eval(test.input, test.env)
+		result, err := expr.Eval(test.input, test.env)
 		if err == nil {
-			err = fmt.Errorf("<nil>")
+			err = fmt.Errorf("%v, <nil>", result)
 		}
 		if !strings.HasPrefix(err.Error(), test.err) || test.err == "" {
 			t.Errorf("%s:\ngot\n\t%+v\nexpected\n\t%v", test.input, err.Error(), test.err)

lexer_test.go

@@ -10,6 +10,11 @@ type lexTest struct {
 	tokens []token
 }
 
+type lexErrorTest struct {
+	input string
+	err   string
+}
+
 var lexTests = []lexTest{
 	{
 		"1 02 1e3 1.2e-4",
@@ -94,11 +99,6 @@ var lexTests = []lexTest{
 	},
 }
 
-type lexErrorTest struct {
-	input string
-	err   string
-}
-
 var lexErrorTests = []lexErrorTest{
 	{
 		`{[}]`,

parser_test.go

@@ -12,6 +12,11 @@ type parseTest struct {
 	expected Node
 }
 
+type parseErrorTest struct {
+	input string
+	err   string
+}
+
 var parseTests = []parseTest{
 	{
 		"a",
@@ -143,11 +148,6 @@ var parseTests = []parseTest{
 	},
 }
 
-type parseErrorTest struct {
-	input string
-	err   string
-}
-
 var parseErrorTests = []parseErrorTest{
 	{
 		"foo.",