Optimize method calls and builtins opcodes

Author: antonmedv

ast/node.go

@@ -48,9 +48,11 @@ type NilNode struct {
 
 type IdentifierNode struct {
 	base
-	Value string
-	Deref bool
-	Index []int
+	Value       string
+	Deref       bool
+	FieldIndex  []int
+	Method      bool
+	MethodIndex int
 }
 
 type IntegerNode struct {
@@ -105,12 +107,14 @@ type ChainNode struct {
 
 type MemberNode struct {
 	base
-	Node     Node
-	Property Node
-	Optional bool
-	Deref    bool
-	Index    []int
-	Name     string
+	Node        Node
+	Property    Node
+	Name        string
+	Optional    bool
+	Deref       bool
+	FieldIndex  []int
+	Method      bool
+	MethodIndex int
 }
 
 type SliceNode struct {

bench_test.go

@@ -129,21 +129,36 @@ func Benchmark_accessMap(b *testing.B) {
 	}
 }
 
-func Benchmark_call(b *testing.B) {
-	type Env struct {
-		Fn func(string, string, string) bool
-	}
+type CallEnv struct {
+	A      int
+	B      int
+	C      int
+	Fn     func() bool
+	FnFast func(...interface{}) interface{}
+	Foo    CallFoo
+}
+
+func (CallEnv) Func() string {
+	return "func"
+}
+
+type CallFoo struct {
+	D int
+	E int
+	F int
+}
+
+func (CallFoo) Method() string {
+	return "method"
+}
 
-	program, err := expr.Compile(`Fn("a", "b", "ab")`, expr.Env(Env{}))
+func Benchmark_callFunc(b *testing.B) {
+	program, err := expr.Compile(`Func()`, expr.Env(CallEnv{}))
 	if err != nil {
 		b.Fatal(err)
 	}
 
-	env := Env{
-		Fn: func(s1, s2, s3 string) bool {
-			return s1+s2 == s3
-		},
-	}
+	env := CallEnv{}
 
 	for n := 0; n < b.N; n++ {
 		_, err = vm.Run(program, env)
@@ -154,19 +169,32 @@ func Benchmark_call(b *testing.B) {
 	}
 }
 
-func Benchmark_callFast(b *testing.B) {
-	type Env struct {
-		Fn func(...interface{}) interface{}
+func Benchmark_callMethod(b *testing.B) {
+	program, err := expr.Compile(`Foo.Method()`, expr.Env(CallEnv{}))
+	if err != nil {
+		b.Fatal(err)
+	}
+
+	env := CallEnv{}
+
+	for n := 0; n < b.N; n++ {
+		_, err = vm.Run(program, env)
+	}
+
+	if err != nil {
+		b.Fatal(err)
 	}
+}
 
-	program, err := expr.Compile(`Fn("a", "b", "ab")`, expr.Env(Env{}))
+func Benchmark_callField(b *testing.B) {
+	program, err := expr.Compile(`Fn()`, expr.Env(CallEnv{}))
 	if err != nil {
 		b.Fatal(err)
 	}
 
-	env := Env{
-		Fn: func(s ...interface{}) interface{} {
-			return s[0].(string)+s[1].(string) == s[2].(string)
+	env := CallEnv{
+		Fn: func() bool {
+			return true
 		},
 	}
 
@@ -179,16 +207,39 @@ func Benchmark_callFast(b *testing.B) {
 	}
 }
 
-func Benchmark_callConstExpr(b *testing.B) {
-	env := map[string]interface{}{
-		"Fn": func(s ...interface{}) interface{} { return s[0].(string)+s[1].(string) == s[2].(string) },
+func Benchmark_callFast(b *testing.B) {
+	program, err := expr.Compile(`FnFast()`, expr.Env(CallEnv{}))
+	if err != nil {
+		b.Fatal(err)
+	}
+
+	env := CallEnv{
+		FnFast: func(s ...interface{}) interface{} {
+			return "fn_fast"
+		},
+	}
+
+	var out interface{}
+	for n := 0; n < b.N; n++ {
+		out, err = vm.Run(program, env)
+	}
+
+	if err != nil {
+		b.Fatal(err)
 	}
+	if out.(string) != "fn_fast" {
+		b.Fail()
+	}
+}
 
-	program, err := expr.Compile(`Fn("a", "b", "ab")`, expr.Env(env), expr.ConstExpr("Fn"))
+func Benchmark_callConstExpr(b *testing.B) {
+	program, err := expr.Compile(`Func()`, expr.Env(CallEnv{}), expr.ConstExpr("Func"))
 	if err != nil {
 		b.Fatal(err)
 	}
 
+	env := CallEnv{}
+
 	var out interface{}
 	for n := 0; n < b.N; n++ {
 		out, err = vm.Run(program, env)
@@ -197,7 +248,7 @@ func Benchmark_callConstExpr(b *testing.B) {
 	if err != nil {
 		b.Fatal(err)
 	}
-	if !out.(bool) {
+	if out.(string) != "func" {
 		b.Fail()
 	}
 }

checker/checker.go

@@ -133,9 +133,9 @@ func (v *visitor) IdentifierNode(node *ast.IdentifierNode) (reflect.Type, info)
 		}
 		d, c := deref(t.Type)
 		node.Deref = c
-		if !t.Method {
-			node.Index = t.Index
-		}
+		node.Method = t.Method
+		node.MethodIndex = t.MethodIndex
+		node.FieldIndex = t.FieldIndex
 		return d, info{method: t.Method}
 	}
 	if !v.config.Strict {
@@ -367,6 +367,9 @@ func (v *visitor) MemberNode(node *ast.MemberNode) (reflect.Type, info) {
 		// First, check methods defined on base type itself,
 		// independent of which type it is. Without dereferencing.
 		if m, ok := base.MethodByName(name.Value); ok {
+			node.Method = true
+			node.MethodIndex = m.Index
+			node.Name = name.Value
 			if base.Kind() == reflect.Interface {
 				// In case of interface type method will not have a receiver,
 				// and to prevent checker decreasing numbers of in arguments
@@ -408,7 +411,7 @@ func (v *visitor) MemberNode(node *ast.MemberNode) (reflect.Type, info) {
 			if field, ok := fetchField(base, propertyName); ok {
 				t, c := deref(field.Type)
 				node.Deref = c
-				node.Index = field.Index
+				node.FieldIndex = field.Index
 				node.Name = propertyName
 				return t, info{}
 			}

checker/checker_test.go

@@ -10,9 +10,9 @@ import (
 	"github.com/antonmedv/expr"
 	"github.com/antonmedv/expr/ast"
 	"github.com/antonmedv/expr/checker"
-	"github.com/antonmedv/expr/checker/mock"
 	"github.com/antonmedv/expr/conf"
 	"github.com/antonmedv/expr/parser"
+	"github.com/antonmedv/expr/test/mock"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
@@ -77,7 +77,8 @@ var successTests = []string{
 	"Foo.Bar == MapOfAny.id.Bar",
 	"Foo.Bar.Baz == ''",
 	"MapOfFoo['any'].Bar.Baz == ''",
-	"Func(Foo) > 1",
+	"Func() == 0",
+	"FuncFoo(Foo) > 1",
 	"Any() > 0",
 	"Embed.EmbedString == ''",
 	"EmbedString == ''",