Refactor visitor

Author: antonmedv

README.md

@@ -31,7 +31,7 @@ product.Stock < 15
 * Static typing ([example](https://godoc.org/github.com/antonmedv/expr#example-Env)).
   ```go
   out, err := expr.Eval("'hello' + 10")
-  // err: invalid operation + (mismatched types string and int64)
+  // err: invalid operation + (mismatched types string and int)
   // | 'hello' + 10
   // | ........^
   ```

ast/base_visitor.go

@@ -3,27 +3,8 @@ package ast
 import "fmt"
 
 type Visitor interface {
-	NilNode(node *NilNode)
-	IdentifierNode(node *IdentifierNode)
-	IntegerNode(node *IntegerNode)
-	FloatNode(node *FloatNode)
-	BoolNode(node *BoolNode)
-	StringNode(node *StringNode)
-	UnaryNode(node *UnaryNode)
-	BinaryNode(node *BinaryNode)
-	MatchesNode(node *MatchesNode)
-	PropertyNode(node *PropertyNode)
-	IndexNode(node *IndexNode)
-	MethodNode(node *MethodNode)
-	FunctionNode(node *FunctionNode)
-	BuiltinNode(node *BuiltinNode)
-	ClosureNode(node *ClosureNode)
-	PointerNode(node *PointerNode)
-	ConditionalNode(node *ConditionalNode)
-	ArrayNode(node *ArrayNode)
-	MapNode(node *MapNode)
-	PairNode(node *PairNode)
-	Node(node *Node)
+	Enter(node *Node)
+	Exit(node *Node)
 }
 
 type walker struct {
@@ -38,79 +19,79 @@ func Walk(node *Node, visitor Visitor) {
 }
 
 func (w *walker) walk(node *Node) {
-	w.visitor.Node(node)
+	w.visitor.Enter(node)
 
 	switch n := (*node).(type) {
 	case *NilNode:
-		w.visitor.NilNode(n)
+		w.visitor.Exit(node)
 	case *IdentifierNode:
-		w.visitor.IdentifierNode(n)
+		w.visitor.Exit(node)
 	case *IntegerNode:
-		w.visitor.IntegerNode(n)
+		w.visitor.Exit(node)
 	case *FloatNode:
-		w.visitor.FloatNode(n)
+		w.visitor.Exit(node)
 	case *BoolNode:
-		w.visitor.BoolNode(n)
+		w.visitor.Exit(node)
 	case *StringNode:
-		w.visitor.StringNode(n)
+		w.visitor.Exit(node)
 	case *UnaryNode:
 		w.walk(&n.Node)
-		w.visitor.UnaryNode(n)
+		w.visitor.Exit(node)
 	case *BinaryNode:
 		w.walk(&n.Left)
 		w.walk(&n.Right)
-		w.visitor.BinaryNode(n)
+		w.visitor.Exit(node)
 	case *MatchesNode:
 		w.walk(&n.Left)
 		w.walk(&n.Right)
-		w.visitor.MatchesNode(n)
+		w.visitor.Exit(node)
 	case *PropertyNode:
 		w.walk(&n.Node)
-		w.visitor.PropertyNode(n)
+		w.visitor.Exit(node)
 	case *IndexNode:
 		w.walk(&n.Node)
 		w.walk(&n.Index)
-		w.visitor.IndexNode(n)
+		w.visitor.Exit(node)
 	case *MethodNode:
 		w.walk(&n.Node)
 		for _, arg := range n.Arguments {
 			w.walk(&arg)
 		}
-		w.visitor.MethodNode(n)
+		w.visitor.Exit(node)
 	case *FunctionNode:
 		for _, arg := range n.Arguments {
 			w.walk(&arg)
 		}
-		w.visitor.FunctionNode(n)
+		w.visitor.Exit(node)
 	case *BuiltinNode:
 		for _, arg := range n.Arguments {
 			w.walk(&arg)
 		}
-		w.visitor.BuiltinNode(n)
+		w.visitor.Exit(node)
 	case *ClosureNode:
 		w.walk(&n.Node)
-		w.visitor.ClosureNode(n)
+		w.visitor.Exit(node)
 	case *PointerNode:
-		w.visitor.PointerNode(n)
+		w.visitor.Exit(node)
 	case *ConditionalNode:
 		w.walk(&n.Cond)
 		w.walk(&n.Exp1)
 		w.walk(&n.Exp2)
-		w.visitor.ConditionalNode(n)
+		w.visitor.Exit(node)
 	case *ArrayNode:
 		for _, node := range n.Nodes {
 			w.walk(&node)
 		}
-		w.visitor.ArrayNode(n)
+		w.visitor.Exit(node)
 	case *MapNode:
 		var pair Node
 		for _, pair = range n.Pairs {
 			w.walk(&pair)
 		}
-		w.visitor.MapNode(n)
+		w.visitor.Exit(node)
 	case *PairNode:
 		w.walk(&n.Value)
-		w.visitor.PairNode(n)
+		w.visitor.Exit(node)
 	default:
 		panic(fmt.Sprintf("undefined node type (%T)", node))
 	}

ast/visitor.go

@@ -7,12 +7,14 @@ import (
 )
 
 type visitor struct {
-	ast.BaseVisitor
 	identifiers []string
 }
 
-func (v *visitor) IdentifierNode(node *ast.IdentifierNode) {
-	v.identifiers = append(v.identifiers, node.Value)
+func (v *visitor) Enter(node *ast.Node) {}
+func (v *visitor) Exit(node *ast.Node) {
+	if n, ok := (*node).(*ast.IdentifierNode); ok {
+		v.identifiers = append(v.identifiers, n.Value)
+	}
 }
 
 func TestWalk(t *testing.T) {
@@ -28,15 +30,14 @@ func TestWalk(t *testing.T) {
 	assert.Equal(t, []string{"foo", "bar"}, visitor.identifiers)
 }
 
-type patcher struct {
-	ast.BaseVisitor
-}
+type patcher struct{}
 
-func (p *patcher) Node(node *ast.Node) {
+func (p *patcher) Enter(node *ast.Node) {
 	if _, ok := (*node).(*ast.IdentifierNode); ok {
 		*node = &ast.NilNode{}
 	}
 }
+func (p *patcher) Exit(node *ast.Node) {}
 
 func TestWalk_patch(t *testing.T) {
 	var node ast.Node

ast/visitor_test.go

@@ -31,11 +31,6 @@ func Check(tree *parser.Tree, config *conf.Config) (t reflect.Type, err error) {
 
 	t = v.visit(tree.Node)
 
-	// TODO: Move patch into visitor.
-	if v.operators != nil {
-		patchOperators(tree, config)
-	}
-
 	if v.expect != reflect.Invalid {
 		switch v.expect {
 		case reflect.Int64, reflect.Float64:

checker/checker.go

@@ -7,12 +7,12 @@ import (
 )
 
 type operatorPatcher struct {
-	ast.BaseVisitor
 	ops   map[string][]string
 	types conf.TypesTable
 }
 
-func (p *operatorPatcher) Node(node *ast.Node) {
+func (p *operatorPatcher) Enter(node *ast.Node) {}
+func (p *operatorPatcher) Exit(node *ast.Node) {
 	binaryNode, ok := (*node).(*ast.BinaryNode)
 	if !ok {
 		return
@@ -40,7 +40,7 @@ func (p *operatorPatcher) Node(node *ast.Node) {
 	}
 }
 
-func patchOperators(tree *parser.Tree, config *conf.Config) {
+func PatchOperators(tree *parser.Tree, config *conf.Config) {
 	if len(config.Operators) == 0 {
 		return
 	}