Add constant folding optimization

Author: antonmedv

ast/location.go

@@ -52,6 +52,14 @@ func (n *StringNode) GetLocation() file.Location {
 	return n.l
 }
 
+func (n *ConstantNode) SetLocation(l file.Location) {
+	n.l = l
+}
+
+func (n *ConstantNode) GetLocation() file.Location {
+	return n.l
+}
+
 func (n *UnaryNode) SetLocation(l file.Location) {
 	n.l = l
 }

ast/node.go

@@ -54,6 +54,13 @@ type StringNode struct {
 	Value string
 }
 
+type ConstantNode struct {
+	l file.Location
+	t reflect.Type
+
+	Value interface{}
+}
+
 type UnaryNode struct {
 	l file.Location
 	t reflect.Type

ast/type.go

@@ -50,6 +50,14 @@ func (n *StringNode) GetType() reflect.Type {
 	return n.t
 }
 
+func (n *ConstantNode) SetType(t reflect.Type) {
+	n.t = t
+}
+
+func (n *ConstantNode) GetType() reflect.Type {
+	return n.t
+}
+
 func (n *UnaryNode) SetType(t reflect.Type) {
 	n.t = t
 }

ast/visitor.go

@@ -34,6 +34,8 @@ func (w *walker) walk(node *Node) {
 		w.visitor.Exit(node)
 	case *StringNode:
 		w.visitor.Exit(node)
+	case *ConstantNode:
+		w.visitor.Exit(node)
 	case *UnaryNode:
 		w.walk(&n.Node)
 		w.visitor.Exit(node)
@@ -53,8 +55,12 @@ func (w *walker) walk(node *Node) {
 		w.walk(&n.Index)
 		w.visitor.Exit(node)
 	case *SliceNode:
-		w.walk(&n.From)
-		w.walk(&n.To)
+		if n.From != nil {
+			w.walk(&n.From)
+		}
+		if n.To != nil {
+			w.walk(&n.To)
+		}
 		w.visitor.Exit(node)
 	case *MethodNode:
 		w.walk(&n.Node)

cmd/exe/debugger.go

@@ -3,6 +3,7 @@ package main
 import (
 	"fmt"
 	"github.com/antonmedv/expr/compiler"
+	"github.com/antonmedv/expr/optimizer"
 	"github.com/antonmedv/expr/parser"
 	. "github.com/antonmedv/expr/vm"
 	"github.com/gdamore/tcell"
@@ -18,6 +19,10 @@ func debugger() {
 	tree, err := parser.Parse(input())
 	check(err)
 
+	if opt {
+		optimizer.Optimize(&tree.Node)
+	}
+
 	program, err := compiler.Compile(tree, nil)
 	check(err)
 

cmd/exe/main.go

@@ -4,10 +4,11 @@ import (
 	"bufio"
 	"flag"
 	"fmt"
+	"github.com/antonmedv/expr"
 	"github.com/antonmedv/expr/checker"
 	"github.com/antonmedv/expr/compiler"
+	"github.com/antonmedv/expr/optimizer"
 	"github.com/antonmedv/expr/parser"
-	"github.com/antonmedv/expr/vm"
 	"github.com/sanity-io/litter"
 	"io/ioutil"
 	"os"
@@ -20,6 +21,7 @@ var (
 	ast      bool
 	dot      bool
 	repl     bool
+	opt      bool
 )
 
 func init() {
@@ -29,6 +31,7 @@ func init() {
 	flag.BoolVar(&ast, "ast", false, "print ast")
 	flag.BoolVar(&dot, "dot", false, "dot format")
 	flag.BoolVar(&repl, "repl", false, "start repl")
+	flag.BoolVar(&opt, "opt", true, "do optimization")
 }
 
 func main() {
@@ -82,6 +85,10 @@ func printAst() {
 		return
 	}
 
+	if opt {
+		optimizer.Optimize(&tree.Node)
+	}
+
 	dotAst(tree.Node)
 }
 
@@ -92,23 +99,18 @@ func printDisassemble() {
 	_, err = checker.Check(tree, nil)
 	check(err)
 
+	if opt {
+		optimizer.Optimize(&tree.Node)
+	}
+
 	program, err := compiler.Compile(tree, nil)
 	check(err)
 
 	_, _ = fmt.Fprintf(os.Stdout, program.Disassemble())
 }
 
 func runProgram() {
-	tree, err := parser.Parse(input())
-	check(err)
-
-	_, err = checker.Check(tree, nil)
-	check(err)
-
-	program, err := compiler.Compile(tree, nil)
-	check(err)
-
-	out, err := vm.Run(program, nil)
+	out, err := expr.Eval(input(), nil)
 	check(err)
 
 	litter.Dump(out)
@@ -118,35 +120,9 @@ func startRepl() {
 	scanner := bufio.NewScanner(os.Stdin)
 	fmt.Print("> ")
 
-	var (
-		err     error
-		tree    *parser.Tree
-		program *vm.Program
-		out     interface{}
-	)
-
 	for scanner.Scan() {
 		line := scanner.Text()
-
-		tree, err = parser.Parse(line)
-		if err != nil {
-			fmt.Printf("%v\n", err)
-			goto prompt
-		}
-
-		_, err = checker.Check(tree, nil)
-		if err != nil {
-			fmt.Printf("%v\n", err)
-			goto prompt
-		}
-
-		program, err = compiler.Compile(tree, nil)
-		if err != nil {
-			fmt.Printf("%v\n", err)
-			goto prompt
-		}
-
-		out, err = vm.Run(program, nil)
+		out, err := expr.Eval(line, nil)
 		if err != nil {
 			fmt.Printf("%v\n", err)
 			goto prompt

compiler/compiler.go

@@ -126,6 +126,8 @@ func (c *compiler) compile(node ast.Node) {
 		c.BoolNode(n)
 	case *ast.StringNode:
 		c.StringNode(n)
+	case *ast.ConstantNode:
+		c.ConstantNode(n)
 	case *ast.UnaryNode:
 		c.UnaryNode(n)
 	case *ast.BinaryNode:
@@ -228,6 +230,10 @@ func (c *compiler) StringNode(node *ast.StringNode) {
 	c.emitPush(node.Value)
 }
 
+func (c *compiler) ConstantNode(node *ast.ConstantNode) {
+	c.emitPush(node.Value)
+}
+
 func (c *compiler) UnaryNode(node *ast.UnaryNode) {
 	c.compile(node.Node)
 

expr.go

@@ -4,6 +4,7 @@ import (
 	"github.com/antonmedv/expr/checker"
 	"github.com/antonmedv/expr/compiler"
 	"github.com/antonmedv/expr/internal/conf"
+	"github.com/antonmedv/expr/optimizer"
 	"github.com/antonmedv/expr/parser"
 	"github.com/antonmedv/expr/vm"
 	"reflect"
@@ -70,6 +71,13 @@ func AsFloat64() conf.Option {
 	}
 }
 
+// Optimize turns optimizations on or off.
+func Optimize(b bool) conf.Option {
+	return func(c *conf.Config) {
+		c.Optimize = b
+	}
+}
+
 // Compile parses and compiles given input expression to bytecode program.
 func Compile(input string, ops ...conf.Option) (*vm.Program, error) {
 	config := &conf.Config{Operators: make(map[string][]string)}
@@ -95,6 +103,8 @@ func Compile(input string, ops ...conf.Option) (*vm.Program, error) {
 		checker.PatchOperators(tree, config)
 	}
 
+	optimizer.Optimize(&tree.Node)
+
 	program, err := compiler.Compile(tree, config)
 	if err != nil {
 		return nil, err