walker: leave node event

dumper.go

@@ -10,13 +10,13 @@ type dumper struct {
 	indent string
 }
 
-func (d dumper) Visit(n node.Node) bool {
+func (d dumper) EnterNode(n node.Node) bool {
 	fmt.Printf("%v[%v]:\n", d.indent, n.Name())
 
 	return true
 }
 
-func (d dumper) Children(key string) node.Visitor {
+func (d dumper) GetChildrenVisitor(key string) node.Visitor {
 	fmt.Printf("%v%v:\n", d.indent+". ", key)
 	return dumper{d.indent + ". . "}
 }
@@ -24,3 +24,7 @@ func (d dumper) Children(key string) node.Visitor {
 func (d dumper) Scalar(key string, value interface{}) {
 	fmt.Printf("%v%v: %v\n", d.indent+". ", key, value)
 }
+
+func (d dumper) LeaveNode(n node.Node) {
+	// do nothing
+}

node/argument.go

@@ -19,12 +19,14 @@ func NewArgument(expression Node, variadic bool) Node {
 }
 
 func (n Argument) Walk(v Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.expr != nil {
-		vv := v.Children("expr")
+		vv := v.GetChildrenVisitor("expr")
 		n.expr.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/array.go

@@ -26,14 +26,16 @@ func NewArray(opentToken token.Token, closeToken token.Token, items []node.Node)
 }
 
 func (n Array) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.items != nil {
-		vv := v.Children("items")
+		vv := v.GetChildrenVisitor("items")
 		for _, nn := range n.items {
 			nn.Walk(vv)
 		}
 	}
+
+	v.LeaveNode(n)
 }

node/expr/array_dim_fetch.go

@@ -23,17 +23,19 @@ func NewArrayDimFetch(variable node.Node, dim node.Node) node.Node {
 }
 
 func (n ArrayDimFetch) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.variable != nil {
-		vv := v.Children("variable")
+		vv := v.GetChildrenVisitor("variable")
 		n.variable.Walk(vv)
 	}
 
 	if n.dim != nil {
-		vv := v.Children("dim")
+		vv := v.GetChildrenVisitor("dim")
 		n.dim.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/array_item.go

@@ -25,17 +25,19 @@ func NewArrayItem(key node.Node, val node.Node, byRef bool) node.Node {
 }
 
 func (n ArrayItem) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.key != nil {
-		vv := v.Children("key")
+		vv := v.GetChildrenVisitor("key")
 		n.key.Walk(vv)
 	}
 
 	if n.val != nil {
-		vv := v.Children("val")
+		vv := v.GetChildrenVisitor("val")
 		n.val.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/assign_op/assign.go

@@ -23,17 +23,19 @@ func NewAssign(variable node.Node, expression node.Node) node.Node {
 }
 
 func (n Assign) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.variable != nil {
-		vv := v.Children("variable")
+		vv := v.GetChildrenVisitor("variable")
 		n.variable.Walk(vv)
 	}
 
 	if n.expression != nil {
-		vv := v.Children("expression")
+		vv := v.GetChildrenVisitor("expression")
 		n.expression.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/assign_op/assign_ref.go

@@ -23,17 +23,19 @@ func NewAssignRef(variable node.Node, expression node.Node) node.Node {
 }
 
 func (n AssignRef) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.variable != nil {
-		vv := v.Children("variable")
+		vv := v.GetChildrenVisitor("variable")
 		n.variable.Walk(vv)
 	}
 
 	if n.expression != nil {
-		vv := v.Children("expression")
+		vv := v.GetChildrenVisitor("expression")
 		n.expression.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/assign_op/bitwise_and.go

@@ -23,17 +23,19 @@ func NewBitwiseAnd(variable node.Node, expression node.Node) node.Node {
 }
 
 func (n BitwiseAnd) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.variable != nil {
-		vv := v.Children("variable")
+		vv := v.GetChildrenVisitor("variable")
 		n.variable.Walk(vv)
 	}
 
 	if n.expression != nil {
-		vv := v.Children("expression")
+		vv := v.GetChildrenVisitor("expression")
 		n.expression.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/assign_op/bitwise_or.go

@@ -23,17 +23,19 @@ func NewBitwiseOr(variable node.Node, expression node.Node) node.Node {
 }
 
 func (n BitwiseOr) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.variable != nil {
-		vv := v.Children("variable")
+		vv := v.GetChildrenVisitor("variable")
 		n.variable.Walk(vv)
 	}
 
 	if n.expression != nil {
-		vv := v.Children("expression")
+		vv := v.GetChildrenVisitor("expression")
 		n.expression.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/assign_op/bitwise_xor.go

@@ -23,17 +23,19 @@ func (n BitwiseXor) Name() string {
 }
 
 func (n BitwiseXor) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.variable != nil {
-		vv := v.Children("variable")
+		vv := v.GetChildrenVisitor("variable")
 		n.variable.Walk(vv)
 	}
 
 	if n.expression != nil {
-		vv := v.Children("expression")
+		vv := v.GetChildrenVisitor("expression")
 		n.expression.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/assign_op/concat.go

@@ -23,17 +23,19 @@ func NewConcat(variable node.Node, expression node.Node) node.Node {
 }
 
 func (n Concat) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.variable != nil {
-		vv := v.Children("variable")
+		vv := v.GetChildrenVisitor("variable")
 		n.variable.Walk(vv)
 	}
 
 	if n.expression != nil {
-		vv := v.Children("expression")
+		vv := v.GetChildrenVisitor("expression")
 		n.expression.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/assign_op/div.go

@@ -23,17 +23,19 @@ func NewDiv(variable node.Node, expression node.Node) node.Node {
 }
 
 func (n Div) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.variable != nil {
-		vv := v.Children("variable")
+		vv := v.GetChildrenVisitor("variable")
 		n.variable.Walk(vv)
 	}
 
 	if n.expression != nil {
-		vv := v.Children("expression")
+		vv := v.GetChildrenVisitor("expression")
 		n.expression.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/assign_op/minus.go

@@ -23,17 +23,19 @@ func NewMinus(variable node.Node, expression node.Node) node.Node {
 }
 
 func (n Minus) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.variable != nil {
-		vv := v.Children("variable")
+		vv := v.GetChildrenVisitor("variable")
 		n.variable.Walk(vv)
 	}
 
 	if n.expression != nil {
-		vv := v.Children("expression")
+		vv := v.GetChildrenVisitor("expression")
 		n.expression.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/assign_op/mod.go

@@ -23,17 +23,19 @@ func NewMod(variable node.Node, expression node.Node) node.Node {
 }
 
 func (n Mod) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.variable != nil {
-		vv := v.Children("variable")
+		vv := v.GetChildrenVisitor("variable")
 		n.variable.Walk(vv)
 	}
 
 	if n.expression != nil {
-		vv := v.Children("expression")
+		vv := v.GetChildrenVisitor("expression")
 		n.expression.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/assign_op/mul.go

@@ -23,17 +23,19 @@ func NewMul(variable node.Node, expression node.Node) node.Node {
 }
 
 func (n Mul) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.variable != nil {
-		vv := v.Children("variable")
+		vv := v.GetChildrenVisitor("variable")
 		n.variable.Walk(vv)
 	}
 
 	if n.expression != nil {
-		vv := v.Children("expression")
+		vv := v.GetChildrenVisitor("expression")
 		n.expression.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/assign_op/plus.go

@@ -23,17 +23,19 @@ func NewPlus(variable node.Node, expression node.Node) node.Node {
 }
 
 func (n Plus) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.variable != nil {
-		vv := v.Children("variable")
+		vv := v.GetChildrenVisitor("variable")
 		n.variable.Walk(vv)
 	}
 
 	if n.expression != nil {
-		vv := v.Children("expression")
+		vv := v.GetChildrenVisitor("expression")
 		n.expression.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/assign_op/pow.go

@@ -23,17 +23,19 @@ func NewPow(variable node.Node, expression node.Node) node.Node {
 }
 
 func (n Pow) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.variable != nil {
-		vv := v.Children("variable")
+		vv := v.GetChildrenVisitor("variable")
 		n.variable.Walk(vv)
 	}
 
 	if n.expression != nil {
-		vv := v.Children("expression")
+		vv := v.GetChildrenVisitor("expression")
 		n.expression.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/assign_op/shift_left.go

@@ -23,17 +23,19 @@ func NewShiftLeft(variable node.Node, expression node.Node) node.Node {
 }
 
 func (n ShiftLeft) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.variable != nil {
-		vv := v.Children("variable")
+		vv := v.GetChildrenVisitor("variable")
 		n.variable.Walk(vv)
 	}
 
 	if n.expression != nil {
-		vv := v.Children("expression")
+		vv := v.GetChildrenVisitor("expression")
 		n.expression.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/assign_op/shift_right.go

@@ -23,17 +23,19 @@ func NewShiftRight(variable node.Node, expression node.Node) node.Node {
 }
 
 func (n ShiftRight) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.variable != nil {
-		vv := v.Children("variable")
+		vv := v.GetChildrenVisitor("variable")
 		n.variable.Walk(vv)
 	}
 
 	if n.expression != nil {
-		vv := v.Children("expression")
+		vv := v.GetChildrenVisitor("expression")
 		n.expression.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/binary_op/bitwise_and.go

@@ -23,17 +23,19 @@ func NewBitwiseAnd(variable node.Node, expression node.Node) node.Node {
 }
 
 func (n BitwiseAnd) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.left != nil {
-		vv := v.Children("left")
+		vv := v.GetChildrenVisitor("left")
 		n.left.Walk(vv)
 	}
 
 	if n.right != nil {
-		vv := v.Children("right")
+		vv := v.GetChildrenVisitor("right")
 		n.right.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/binary_op/bitwise_or.go

@@ -23,17 +23,19 @@ func (n BitwiseOr) Name() string {
 }
 
 func (n BitwiseOr) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.left != nil {
-		vv := v.Children("left")
+		vv := v.GetChildrenVisitor("left")
 		n.left.Walk(vv)
 	}
 
 	if n.right != nil {
-		vv := v.Children("right")
+		vv := v.GetChildrenVisitor("right")
 		n.right.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/binary_op/bitwise_xor.go

@@ -23,17 +23,19 @@ func (n BitwiseXor) Name() string {
 }
 
 func (n BitwiseXor) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.left != nil {
-		vv := v.Children("left")
+		vv := v.GetChildrenVisitor("left")
 		n.left.Walk(vv)
 	}
 
 	if n.right != nil {
-		vv := v.Children("right")
+		vv := v.GetChildrenVisitor("right")
 		n.right.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/binary_op/boolean_and.go

@@ -23,17 +23,19 @@ func NewBooleanAnd(variable node.Node, expression node.Node) node.Node {
 }
 
 func (n BooleanAnd) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.left != nil {
-		vv := v.Children("left")
+		vv := v.GetChildrenVisitor("left")
 		n.left.Walk(vv)
 	}
 
 	if n.right != nil {
-		vv := v.Children("right")
+		vv := v.GetChildrenVisitor("right")
 		n.right.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/binary_op/boolean_or.go

@@ -23,17 +23,19 @@ func NewBooleanOr(variable node.Node, expression node.Node) node.Node {
 }
 
 func (n BooleanOr) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.left != nil {
-		vv := v.Children("left")
+		vv := v.GetChildrenVisitor("left")
 		n.left.Walk(vv)
 	}
 
 	if n.right != nil {
-		vv := v.Children("right")
+		vv := v.GetChildrenVisitor("right")
 		n.right.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/binary_op/coalesce.go

@@ -23,17 +23,19 @@ func NewCoalesce(variable node.Node, expression node.Node) node.Node {
 }
 
 func (n Coalesce) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.left != nil {
-		vv := v.Children("left")
+		vv := v.GetChildrenVisitor("left")
 		n.left.Walk(vv)
 	}
 
 	if n.right != nil {
-		vv := v.Children("right")
+		vv := v.GetChildrenVisitor("right")
 		n.right.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/binary_op/concat.go

@@ -23,17 +23,19 @@ func NewConcat(variable node.Node, expression node.Node) node.Node {
 }
 
 func (n Concat) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.left != nil {
-		vv := v.Children("left")
+		vv := v.GetChildrenVisitor("left")
 		n.left.Walk(vv)
 	}
 
 	if n.right != nil {
-		vv := v.Children("right")
+		vv := v.GetChildrenVisitor("right")
 		n.right.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/binary_op/div.go

@@ -23,17 +23,19 @@ func NewDiv(variable node.Node, expression node.Node) node.Node {
 }
 
 func (n Div) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.left != nil {
-		vv := v.Children("left")
+		vv := v.GetChildrenVisitor("left")
 		n.left.Walk(vv)
 	}
 
 	if n.right != nil {
-		vv := v.Children("right")
+		vv := v.GetChildrenVisitor("right")
 		n.right.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/binary_op/equal.go

@@ -23,17 +23,19 @@ func NewEqual(variable node.Node, expression node.Node) node.Node {
 }
 
 func (n Equal) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.left != nil {
-		vv := v.Children("left")
+		vv := v.GetChildrenVisitor("left")
 		n.left.Walk(vv)
 	}
 
 	if n.right != nil {
-		vv := v.Children("right")
+		vv := v.GetChildrenVisitor("right")
 		n.right.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/binary_op/greater.go

@@ -23,17 +23,19 @@ func NewGreater(variable node.Node, expression node.Node) node.Node {
 }
 
 func (n Greater) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.left != nil {
-		vv := v.Children("left")
+		vv := v.GetChildrenVisitor("left")
 		n.left.Walk(vv)
 	}
 
 	if n.right != nil {
-		vv := v.Children("right")
+		vv := v.GetChildrenVisitor("right")
 		n.right.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/binary_op/greater_or_equal.go

@@ -23,17 +23,19 @@ func NewGreaterOrEqual(variable node.Node, expression node.Node) node.Node {
 }
 
 func (n GreaterOrEqual) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.left != nil {
-		vv := v.Children("left")
+		vv := v.GetChildrenVisitor("left")
 		n.left.Walk(vv)
 	}
 
 	if n.right != nil {
-		vv := v.Children("right")
+		vv := v.GetChildrenVisitor("right")
 		n.right.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/binary_op/identical.go

@@ -23,17 +23,19 @@ func NewIdentical(variable node.Node, expression node.Node) node.Node {
 }
 
 func (n Identical) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.left != nil {
-		vv := v.Children("left")
+		vv := v.GetChildrenVisitor("left")
 		n.left.Walk(vv)
 	}
 
 	if n.right != nil {
-		vv := v.Children("right")
+		vv := v.GetChildrenVisitor("right")
 		n.right.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/binary_op/logical_and.go

@@ -23,17 +23,19 @@ func NewLogicalAnd(variable node.Node, expression node.Node) node.Node {
 }
 
 func (n LogicalAnd) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.left != nil {
-		vv := v.Children("left")
+		vv := v.GetChildrenVisitor("left")
 		n.left.Walk(vv)
 	}
 
 	if n.right != nil {
-		vv := v.Children("right")
+		vv := v.GetChildrenVisitor("right")
 		n.right.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/binary_op/logical_or.go

@@ -23,17 +23,19 @@ func NewLogicalOr(variable node.Node, expression node.Node) node.Node {
 }
 
 func (n LogicalOr) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.left != nil {
-		vv := v.Children("left")
+		vv := v.GetChildrenVisitor("left")
 		n.left.Walk(vv)
 	}
 
 	if n.right != nil {
-		vv := v.Children("right")
+		vv := v.GetChildrenVisitor("right")
 		n.right.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/binary_op/logical_xor.go

@@ -23,17 +23,19 @@ func NewLogicalXor(variable node.Node, expression node.Node) node.Node {
 }
 
 func (n LogicalXor) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.left != nil {
-		vv := v.Children("left")
+		vv := v.GetChildrenVisitor("left")
 		n.left.Walk(vv)
 	}
 
 	if n.right != nil {
-		vv := v.Children("right")
+		vv := v.GetChildrenVisitor("right")
 		n.right.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/binary_op/minus.go

@@ -23,17 +23,19 @@ func NewMinus(variable node.Node, expression node.Node) node.Node {
 }
 
 func (n Minus) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.left != nil {
-		vv := v.Children("left")
+		vv := v.GetChildrenVisitor("left")
 		n.left.Walk(vv)
 	}
 
 	if n.right != nil {
-		vv := v.Children("right")
+		vv := v.GetChildrenVisitor("right")
 		n.right.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/binary_op/mod.go

@@ -23,17 +23,19 @@ func NewMod(variable node.Node, expression node.Node) node.Node {
 }
 
 func (n Mod) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.left != nil {
-		vv := v.Children("left")
+		vv := v.GetChildrenVisitor("left")
 		n.left.Walk(vv)
 	}
 
 	if n.right != nil {
-		vv := v.Children("right")
+		vv := v.GetChildrenVisitor("right")
 		n.right.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/binary_op/mul.go

@@ -23,17 +23,19 @@ func NewMul(variable node.Node, expression node.Node) node.Node {
 }
 
 func (n Mul) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.left != nil {
-		vv := v.Children("left")
+		vv := v.GetChildrenVisitor("left")
 		n.left.Walk(vv)
 	}
 
 	if n.right != nil {
-		vv := v.Children("right")
+		vv := v.GetChildrenVisitor("right")
 		n.right.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/binary_op/not_equal.go

@@ -23,17 +23,19 @@ func NewNotEqual(variable node.Node, expression node.Node) node.Node {
 }
 
 func (n NotEqual) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.left != nil {
-		vv := v.Children("left")
+		vv := v.GetChildrenVisitor("left")
 		n.left.Walk(vv)
 	}
 
 	if n.right != nil {
-		vv := v.Children("right")
+		vv := v.GetChildrenVisitor("right")
 		n.right.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/binary_op/not_identical.go

@@ -23,17 +23,19 @@ func NewNotIdentical(variable node.Node, expression node.Node) node.Node {
 }
 
 func (n NotIdentical) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.left != nil {
-		vv := v.Children("left")
+		vv := v.GetChildrenVisitor("left")
 		n.left.Walk(vv)
 	}
 
 	if n.right != nil {
-		vv := v.Children("right")
+		vv := v.GetChildrenVisitor("right")
 		n.right.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/binary_op/plus.go

@@ -23,17 +23,19 @@ func NewPlus(variable node.Node, expression node.Node) node.Node {
 }
 
 func (n Plus) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.left != nil {
-		vv := v.Children("left")
+		vv := v.GetChildrenVisitor("left")
 		n.left.Walk(vv)
 	}
 
 	if n.right != nil {
-		vv := v.Children("right")
+		vv := v.GetChildrenVisitor("right")
 		n.right.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/binary_op/pow.go

@@ -23,17 +23,19 @@ func NewPow(variable node.Node, expression node.Node) node.Node {
 }
 
 func (n Pow) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.left != nil {
-		vv := v.Children("left")
+		vv := v.GetChildrenVisitor("left")
 		n.left.Walk(vv)
 	}
 
 	if n.right != nil {
-		vv := v.Children("right")
+		vv := v.GetChildrenVisitor("right")
 		n.right.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/binary_op/shift_left.go

@@ -23,17 +23,19 @@ func NewShiftLeft(variable node.Node, expression node.Node) node.Node {
 }
 
 func (n ShiftLeft) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.left != nil {
-		vv := v.Children("left")
+		vv := v.GetChildrenVisitor("left")
 		n.left.Walk(vv)
 	}
 
 	if n.right != nil {
-		vv := v.Children("right")
+		vv := v.GetChildrenVisitor("right")
 		n.right.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/binary_op/shift_right.go

@@ -23,17 +23,19 @@ func NewShiftRight(variable node.Node, expression node.Node) node.Node {
 }
 
 func (n ShiftRight) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.left != nil {
-		vv := v.Children("left")
+		vv := v.GetChildrenVisitor("left")
 		n.left.Walk(vv)
 	}
 
 	if n.right != nil {
-		vv := v.Children("right")
+		vv := v.GetChildrenVisitor("right")
 		n.right.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/binary_op/smaller.go

@@ -23,17 +23,19 @@ func NewSmaller(variable node.Node, expression node.Node) node.Node {
 }
 
 func (n Smaller) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.left != nil {
-		vv := v.Children("left")
+		vv := v.GetChildrenVisitor("left")
 		n.left.Walk(vv)
 	}
 
 	if n.right != nil {
-		vv := v.Children("right")
+		vv := v.GetChildrenVisitor("right")
 		n.right.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/binary_op/smaller_or_equal.go

@@ -23,17 +23,19 @@ func NewSmallerOrEqual(variable node.Node, expression node.Node) node.Node {
 }
 
 func (n SmallerOrEqual) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.left != nil {
-		vv := v.Children("left")
+		vv := v.GetChildrenVisitor("left")
 		n.left.Walk(vv)
 	}
 
 	if n.right != nil {
-		vv := v.Children("right")
+		vv := v.GetChildrenVisitor("right")
 		n.right.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/binary_op/spaceship.go

@@ -23,17 +23,19 @@ func NewSpaceship(variable node.Node, expression node.Node) node.Node {
 }
 
 func (n Spaceship) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.left != nil {
-		vv := v.Children("left")
+		vv := v.GetChildrenVisitor("left")
 		n.left.Walk(vv)
 	}
 
 	if n.right != nil {
-		vv := v.Children("right")
+		vv := v.GetChildrenVisitor("right")
 		n.right.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/bitwise_not.go

@@ -21,12 +21,14 @@ func NewBitwiseNot(expression node.Node) node.Node {
 }
 
 func (n BitwiseNot) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.expr != nil {
-		vv := v.Children("expr")
+		vv := v.GetChildrenVisitor("expr")
 		n.expr.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/boolean_not.go

@@ -21,12 +21,14 @@ func NewBooleanNot(expression node.Node) node.Node {
 }
 
 func (n BooleanNot) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.expr != nil {
-		vv := v.Children("expr")
+		vv := v.GetChildrenVisitor("expr")
 		n.expr.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/cast/cast_array.go

@@ -22,12 +22,14 @@ func NewCastArray(expr node.Node) node.Node {
 }
 
 func (n CastArray) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.expr != nil {
-		vv := v.Children("expr")
+		vv := v.GetChildrenVisitor("expr")
 		n.expr.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/cast/cast_bool.go

@@ -22,12 +22,14 @@ func NewCastBool(expr node.Node) node.Node {
 }
 
 func (n CastBool) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.expr != nil {
-		vv := v.Children("expr")
+		vv := v.GetChildrenVisitor("expr")
 		n.expr.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/cast/cast_double.go

@@ -22,12 +22,14 @@ func NewCastDouble(expr node.Node) node.Node {
 }
 
 func (n CastDouble) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.expr != nil {
-		vv := v.Children("expr")
+		vv := v.GetChildrenVisitor("expr")
 		n.expr.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/cast/cast_int.go

@@ -22,12 +22,14 @@ func NewCastInt(expr node.Node) node.Node {
 }
 
 func (n CastInt) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.expr != nil {
-		vv := v.Children("expr")
+		vv := v.GetChildrenVisitor("expr")
 		n.expr.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/cast/cast_object.go

@@ -22,12 +22,14 @@ func NewCastObject(expr node.Node) node.Node {
 }
 
 func (n CastObject) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.expr != nil {
-		vv := v.Children("expr")
+		vv := v.GetChildrenVisitor("expr")
 		n.expr.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/cast/cast_string.go

@@ -22,12 +22,14 @@ func NewCastString(expr node.Node) node.Node {
 }
 
 func (n CastString) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.expr != nil {
-		vv := v.Children("expr")
+		vv := v.GetChildrenVisitor("expr")
 		n.expr.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/cast/cast_unset.go

@@ -22,12 +22,14 @@ func NewCastUnset(expr node.Node) node.Node {
 }
 
 func (n CastUnset) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.expr != nil {
-		vv := v.Children("expr")
+		vv := v.GetChildrenVisitor("expr")
 		n.expr.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/class_const_fetch.go

@@ -25,14 +25,16 @@ func NewClassConstFetch(class node.Node, constant token.Token) node.Node {
 }
 
 func (n ClassConstFetch) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	v.Scalar("constant", n.constant.Value)
 
 	if n.class != nil {
-		vv := v.Children("class")
+		vv := v.GetChildrenVisitor("class")
 		n.class.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/clone.go

@@ -21,12 +21,14 @@ func NewClone(expression node.Node) node.Node {
 }
 
 func (n Clone) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.expr != nil {
-		vv := v.Children("expr")
+		vv := v.GetChildrenVisitor("expr")
 		n.expr.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/closure.go

@@ -31,7 +31,7 @@ func NewClosure(params []node.Node, uses []node.Node, returnType node.Node, stmt
 }
 
 func (n Closure) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
@@ -39,28 +39,30 @@ func (n Closure) Walk(v node.Visitor) {
 	v.Scalar("isReturnRef", n.isReturnRef)
 
 	if n.params != nil {
-		vv := v.Children("params")
+		vv := v.GetChildrenVisitor("params")
 		for _, nn := range n.params {
 			nn.Walk(vv)
 		}
 	}
 
 	if n.uses != nil {
-		vv := v.Children("uses")
+		vv := v.GetChildrenVisitor("uses")
 		for _, nn := range n.uses {
 			nn.Walk(vv)
 		}
 	}
 
 	if n.returnType != nil {
-		vv := v.Children("returnType")
+		vv := v.GetChildrenVisitor("returnType")
 		n.returnType.Walk(vv)
 	}
 
 	if n.stmts != nil {
-		vv := v.Children("stmts")
+		vv := v.GetChildrenVisitor("stmts")
 		for _, nn := range n.stmts {
 			nn.Walk(vv)
 		}
 	}
+
+	v.LeaveNode(n)
 }

node/expr/closure_use.go

@@ -23,14 +23,16 @@ func NewClusureUse(variable node.Node, byRef bool) node.Node {
 }
 
 func (n ClusureUse) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	v.Scalar("byRef", n.byRef)
 
 	if n.variable != nil {
-		vv := v.Children("variable")
+		vv := v.GetChildrenVisitor("variable")
 		n.variable.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/const_fetch.go

@@ -21,12 +21,14 @@ func NewConstFetch(constant node.Node) node.Node {
 }
 
 func (n ConstFetch) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.constant != nil {
-		vv := v.Children("constant")
+		vv := v.GetChildrenVisitor("constant")
 		n.constant.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/empty.go

@@ -21,12 +21,14 @@ func NewEmpty(expression node.Node) node.Node {
 }
 
 func (n Empty) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.expr != nil {
-		vv := v.Children("expr")
+		vv := v.GetChildrenVisitor("expr")
 		n.expr.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/error_suppress.go

@@ -21,12 +21,14 @@ func NewErrorSuppress(expression node.Node) node.Node {
 }
 
 func (n ErrorSuppress) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.expr != nil {
-		vv := v.Children("expr")
+		vv := v.GetChildrenVisitor("expr")
 		n.expr.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/eval.go

@@ -21,12 +21,14 @@ func NewEval(expression node.Node) node.Node {
 }
 
 func (n Eval) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.expr != nil {
-		vv := v.Children("expr")
+		vv := v.GetChildrenVisitor("expr")
 		n.expr.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/exit.go

@@ -23,12 +23,14 @@ func NewExit(expr node.Node, isDie bool) node.Node {
 }
 
 func (n Exit) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.expr != nil {
-		vv := v.Children("expr")
+		vv := v.GetChildrenVisitor("expr")
 		n.expr.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/function_call.go

@@ -23,19 +23,21 @@ func NewFunctionCall(function node.Node, arguments []node.Node) node.Node {
 }
 
 func (n FunctionCall) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.function != nil {
-		vv := v.Children("function")
+		vv := v.GetChildrenVisitor("function")
 		n.function.Walk(vv)
 	}
 
 	if n.arguments != nil {
-		vv := v.Children("arguments")
+		vv := v.GetChildrenVisitor("arguments")
 		for _, nn := range n.arguments {
 			nn.Walk(vv)
 		}
 	}
+
+	v.LeaveNode(n)
 }

node/expr/include.go

@@ -21,12 +21,14 @@ func NewInclude(expression node.Node) node.Node {
 }
 
 func (n Include) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.expr != nil {
-		vv := v.Children("expr")
+		vv := v.GetChildrenVisitor("expr")
 		n.expr.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/include_once.go

@@ -21,12 +21,14 @@ func NewIncludeOnce(expression node.Node) node.Node {
 }
 
 func (n IncludeOnce) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.expr != nil {
-		vv := v.Children("expr")
+		vv := v.GetChildrenVisitor("expr")
 		n.expr.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/instance_of.go

@@ -23,17 +23,19 @@ func NewInstanceOf(expr node.Node, class node.Node) node.Node {
 }
 
 func (n InstanceOf) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.expr != nil {
-		vv := v.Children("expr")
+		vv := v.GetChildrenVisitor("expr")
 		n.expr.Walk(vv)
 	}
 
 	if n.class != nil {
-		vv := v.Children("class")
+		vv := v.GetChildrenVisitor("class")
 		n.class.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/isset.go

@@ -21,14 +21,16 @@ func NewIsset(variables []node.Node) node.Node {
 }
 
 func (n Isset) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.variables != nil {
-		vv := v.Children("variables")
+		vv := v.GetChildrenVisitor("variables")
 		for _, nn := range n.variables {
 			nn.Walk(vv)
 		}
 	}
+
+	v.LeaveNode(n)
 }

node/expr/list.go

@@ -21,14 +21,16 @@ func NewList(items []node.Node) node.Node {
 }
 
 func (n List) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.items != nil {
-		vv := v.Children("items")
+		vv := v.GetChildrenVisitor("items")
 		for _, nn := range n.items {
 			nn.Walk(vv)
 		}
 	}
+
+	v.LeaveNode(n)
 }

node/expr/method_call.go

@@ -25,24 +25,26 @@ func NewMethodCall(variable node.Node, method node.Node, arguments []node.Node)
 }
 
 func (n MethodCall) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.variable != nil {
-		vv := v.Children("variable")
+		vv := v.GetChildrenVisitor("variable")
 		n.variable.Walk(vv)
 	}
 
 	if n.method != nil {
-		vv := v.Children("method")
+		vv := v.GetChildrenVisitor("method")
 		n.method.Walk(vv)
 	}
 
 	if n.arguments != nil {
-		vv := v.Children("arguments")
+		vv := v.GetChildrenVisitor("arguments")
 		for _, nn := range n.arguments {
 			nn.Walk(vv)
 		}
 	}
+
+	v.LeaveNode(n)
 }

node/expr/new.go

@@ -23,19 +23,21 @@ func NewNew(class node.Node, arguments []node.Node) node.Node {
 }
 
 func (n New) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.class != nil {
-		vv := v.Children("class")
+		vv := v.GetChildrenVisitor("class")
 		n.class.Walk(vv)
 	}
 
 	if n.arguments != nil {
-		vv := v.Children("arguments")
+		vv := v.GetChildrenVisitor("arguments")
 		for _, nn := range n.arguments {
 			nn.Walk(vv)
 		}
 	}
+
+	v.LeaveNode(n)
 }

node/expr/post_dec.go

@@ -21,12 +21,14 @@ func NewPostDec(variableession node.Node) node.Node {
 }
 
 func (n PostDec) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.variable != nil {
-		vv := v.Children("variable")
+		vv := v.GetChildrenVisitor("variable")
 		n.variable.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/post_inc.go

@@ -21,12 +21,14 @@ func NewPostInc(variableession node.Node) node.Node {
 }
 
 func (n PostInc) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.variable != nil {
-		vv := v.Children("variable")
+		vv := v.GetChildrenVisitor("variable")
 		n.variable.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/pre_dec.go

@@ -21,12 +21,14 @@ func NewPreDec(variableession node.Node) node.Node {
 }
 
 func (n PreDec) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.variable != nil {
-		vv := v.Children("variable")
+		vv := v.GetChildrenVisitor("variable")
 		n.variable.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/pre_inc.go

@@ -21,12 +21,14 @@ func NewPreInc(variableession node.Node) node.Node {
 }
 
 func (n PreInc) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.variable != nil {
-		vv := v.Children("variable")
+		vv := v.GetChildrenVisitor("variable")
 		n.variable.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/print.go

@@ -21,12 +21,14 @@ func NewPrint(expression node.Node) node.Node {
 }
 
 func (n Print) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.expr != nil {
-		vv := v.Children("expr")
+		vv := v.GetChildrenVisitor("expr")
 		n.expr.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/property_fetch.go

@@ -23,17 +23,19 @@ func NewPropertyFetch(variable node.Node, property node.Node) node.Node {
 }
 
 func (n PropertyFetch) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.variable != nil {
-		vv := v.Children("variable")
+		vv := v.GetChildrenVisitor("variable")
 		n.variable.Walk(vv)
 	}
 
 	if n.property != nil {
-		vv := v.Children("property")
+		vv := v.GetChildrenVisitor("property")
 		n.property.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/require.go

@@ -21,12 +21,14 @@ func NewRequire(expression node.Node) node.Node {
 }
 
 func (n Require) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.expr != nil {
-		vv := v.Children("expr")
+		vv := v.GetChildrenVisitor("expr")
 		n.expr.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/require_once.go

@@ -21,12 +21,14 @@ func NewRequireOnce(expression node.Node) node.Node {
 }
 
 func (n RequireOnce) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.expr != nil {
-		vv := v.Children("expr")
+		vv := v.GetChildrenVisitor("expr")
 		n.expr.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/shell_exec.go

@@ -21,14 +21,16 @@ func NewShellExec(parts []node.Node) node.Node {
 }
 
 func (n ShellExec) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.parts != nil {
-		vv := v.Children("parts")
+		vv := v.GetChildrenVisitor("parts")
 		for _, nn := range n.parts {
 			nn.Walk(vv)
 		}
 	}
+
+	v.LeaveNode(n)
 }

node/expr/short_array.go

@@ -26,14 +26,16 @@ func NewShortArray(opentToken token.Token, closeToken token.Token, items []node.
 }
 
 func (n ShortArray) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.items != nil {
-		vv := v.Children("items")
+		vv := v.GetChildrenVisitor("items")
 		for _, nn := range n.items {
 			nn.Walk(vv)
 		}
 	}
+
+	v.LeaveNode(n)
 }

node/expr/short_list.go

@@ -21,14 +21,16 @@ func NewShortList(items []node.Node) node.Node {
 }
 
 func (n ShortList) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.items != nil {
-		vv := v.Children("items")
+		vv := v.GetChildrenVisitor("items")
 		for _, nn := range n.items {
 			nn.Walk(vv)
 		}
 	}
+
+	v.LeaveNode(n)
 }

node/expr/static_call.go

@@ -25,24 +25,26 @@ func NewStaticCall(class node.Node, call node.Node, arguments []node.Node) node.
 }
 
 func (n StaticCall) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.class != nil {
-		vv := v.Children("class")
+		vv := v.GetChildrenVisitor("class")
 		n.class.Walk(vv)
 	}
 
 	if n.call != nil {
-		vv := v.Children("call")
+		vv := v.GetChildrenVisitor("call")
 		n.call.Walk(vv)
 	}
 
 	if n.arguments != nil {
-		vv := v.Children("arguments")
+		vv := v.GetChildrenVisitor("arguments")
 		for _, nn := range n.arguments {
 			nn.Walk(vv)
 		}
 	}
+
+	v.LeaveNode(n)
 }

node/expr/static_property_fetch.go

@@ -23,17 +23,19 @@ func NewStaticPropertyFetch(class node.Node, property node.Node) node.Node {
 }
 
 func (n StaticPropertyFetch) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.class != nil {
-		vv := v.Children("class")
+		vv := v.GetChildrenVisitor("class")
 		n.class.Walk(vv)
 	}
 
 	if n.property != nil {
-		vv := v.Children("property")
+		vv := v.GetChildrenVisitor("property")
 		n.property.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/ternary.go

@@ -25,22 +25,24 @@ func NewTernary(condition node.Node, ifTrue node.Node, ifFalse node.Node) node.N
 }
 
 func (n Ternary) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.condition != nil {
-		vv := v.Children("condition")
+		vv := v.GetChildrenVisitor("condition")
 		n.condition.Walk(vv)
 	}
 
 	if n.ifTrue != nil {
-		vv := v.Children("ifTrue")
+		vv := v.GetChildrenVisitor("ifTrue")
 		n.ifTrue.Walk(vv)
 	}
 
 	if n.ifFalse != nil {
-		vv := v.Children("ifFalse")
+		vv := v.GetChildrenVisitor("ifFalse")
 		n.ifFalse.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/unary_minus.go

@@ -21,12 +21,14 @@ func NewUnaryMinus(expression node.Node) node.Node {
 }
 
 func (n UnaryMinus) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.expr != nil {
-		vv := v.Children("expr")
+		vv := v.GetChildrenVisitor("expr")
 		n.expr.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/unary_plus.go

@@ -21,12 +21,14 @@ func NewUnaryPlus(expression node.Node) node.Node {
 }
 
 func (n UnaryPlus) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.expr != nil {
-		vv := v.Children("expr")
+		vv := v.GetChildrenVisitor("expr")
 		n.expr.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/variable.go

@@ -21,12 +21,14 @@ func NewVariable(varName node.Node) node.Node {
 }
 
 func (n Variable) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.varName != nil {
-		vv := v.Children("varName")
+		vv := v.GetChildrenVisitor("varName")
 		n.varName.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/yield.go

@@ -23,17 +23,19 @@ func NewYield(key node.Node, value node.Node) node.Node {
 }
 
 func (n Yield) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.key != nil {
-		vv := v.Children("key")
+		vv := v.GetChildrenVisitor("key")
 		n.key.Walk(vv)
 	}
 
 	if n.value != nil {
-		vv := v.Children("value")
+		vv := v.GetChildrenVisitor("value")
 		n.value.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/expr/yield_from.go

@@ -21,12 +21,14 @@ func NewYieldFrom(expression node.Node) node.Node {
 }
 
 func (n YieldFrom) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.expr != nil {
-		vv := v.Children("expr")
+		vv := v.GetChildrenVisitor("expr")
 		n.expr.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/identifier.go

@@ -21,9 +21,11 @@ func NewIdentifier(token token.Token) Node {
 }
 
 func (n Identifier) Walk(v Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	v.Scalar("token", n.token.Value)
+
+	v.LeaveNode(n)
 }

node/name/name.go

@@ -21,12 +21,12 @@ func NewName(parts []node.Node) node.Node {
 }
 
 func (n NameNode) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.parts != nil {
-		vv := v.Children("parts")
+		vv := v.GetChildrenVisitor("parts")
 		for _, nn := range n.parts {
 			nn.Walk(vv)
 		}

node/name/name_part.go

@@ -22,7 +22,7 @@ func NewNamePart(token token.Token) node.Node {
 }
 
 func (n NamePart) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 

node/nullable.go

@@ -17,12 +17,14 @@ func NewNullable(expression Node) Node {
 }
 
 func (n Nullable) Walk(v Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.expr != nil {
-		vv := v.Children("expr")
+		vv := v.GetChildrenVisitor("expr")
 		n.expr.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/parameter.go

@@ -25,7 +25,7 @@ func NewParameter(variableType Node, variable Node, defaultValue Node, byRef boo
 }
 
 func (n Parameter) Walk(v Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
@@ -33,17 +33,19 @@ func (n Parameter) Walk(v Visitor) {
 	v.Scalar("variadic", n.variadic)
 
 	if n.variableType != nil {
-		vv := v.Children("variableType")
+		vv := v.GetChildrenVisitor("variableType")
 		n.variableType.Walk(vv)
 	}
 
 	if n.variable != nil {
-		vv := v.Children("variable")
+		vv := v.GetChildrenVisitor("variable")
 		n.variable.Walk(vv)
 	}
 
 	if n.defaultValue != nil {
-		vv := v.Children("defaultValue")
+		vv := v.GetChildrenVisitor("defaultValue")
 		n.defaultValue.Walk(vv)
 	}
+
+	v.LeaveNode(n)
 }

node/scalar/dnumber.go

@@ -22,7 +22,7 @@ func NewDnumber(token token.Token) node.Node {
 }
 
 func (n Dnumber) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 

node/scalar/encapsed.go

@@ -26,12 +26,12 @@ func NewEncapsed(startToken token.Token, parts []node.Node, endToken token.Token
 }
 
 func (n Encapsed) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 
 	if n.parts != nil {
-		vv := v.Children("parts")
+		vv := v.GetChildrenVisitor("parts")
 		for _, nn := range n.parts {
 			nn.Walk(vv)
 		}

node/scalar/encapsed_string_part.go

@@ -22,7 +22,7 @@ func NewEncapsedStringPart(t token.Token) node.Node {
 }
 
 func (n EncapsedStringPart) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}
 

node/scalar/lnumber.go

@@ -22,7 +22,7 @@ func NewLnumber(token token.Token) node.Node {
 }
 
 func (n Lnumber) Walk(v node.Visitor) {
-	if v.Visit(n) == false {
+	if v.EnterNode(n) == false {
 		return
 	}