Separate opcode for int equal

Author: antonmedv

bench_test.go

@@ -10,8 +10,8 @@ func Benchmark_expr(b *testing.B) {
 	params := make(map[string]interface{})
 	params["Origin"] = "MOW"
 	params["Country"] = "RU"
-	params["Adults"] = int64(1)
-	params["Value"] = int64(100)
+	params["Adults"] = 1
+	params["Value"] = 100
 
 	program, err := expr.Compile(`(Origin == "MOW" || Country == "RU") && (Value >= 100 || Adults == 1)`, expr.Env(params))
 	if err != nil {
@@ -52,7 +52,7 @@ func Benchmark_filter(b *testing.B) {
 
 func Benchmark_access(b *testing.B) {
 	type Price struct {
-		Value int64
+		Value int
 	}
 	type Env struct {
 		Price Price

compiler/compiler.go

@@ -250,16 +250,17 @@ func (c *compiler) UnaryNode(node *ast.UnaryNode) {
 }
 
 func (c *compiler) BinaryNode(node *ast.BinaryNode) {
+	l := kind(node.Left)
+	r := kind(node.Right)
 
 	switch node.Operator {
 	case "==":
 		c.compile(node.Left)
 		c.compile(node.Right)
 
-		l := kind(node.Left)
-		r := kind(node.Right)
-
-		if l == reflect.String && r == reflect.String {
+		if l == r && l == reflect.Int {
+			c.emit(OpEqualInt)
+		} else if l == r && l == reflect.String {
 			c.emit(OpEqualString)
 		} else {
 			c.emit(OpEqual)
@@ -299,22 +300,42 @@ func (c *compiler) BinaryNode(node *ast.BinaryNode) {
 	case "<":
 		c.compile(node.Left)
 		c.compile(node.Right)
-		c.emit(OpLess)
+
+		if l == r && l == reflect.Int {
+			c.emit(OpLessInt)
+		} else {
+			c.emit(OpLess)
+		}
 
 	case ">":
 		c.compile(node.Left)
 		c.compile(node.Right)
-		c.emit(OpMore)
 
-	case ">=":
+		if l == r && l == reflect.Int {
+			c.emit(OpMoreInt)
+		} else {
+			c.emit(OpMore)
+		}
+
+	case "<=":
 		c.compile(node.Left)
 		c.compile(node.Right)
-		c.emit(OpMoreOrEqual)
 
-	case "<=":
+		if l == r && l == reflect.Int {
+			c.emit(OpLessOrEqualInt)
+		} else {
+			c.emit(OpLessOrEqual)
+		}
+
+	case ">=":
 		c.compile(node.Left)
 		c.compile(node.Right)
-		c.emit(OpLessOrEqual)
+
+		if l == r && l == reflect.Int {
+			c.emit(OpMoreOrEqualInt)
+		} else {
+			c.emit(OpMoreOrEqual)
+		}
 
 	case "+":
 		c.compile(node.Left)

vm/bytecodes.go

@@ -12,16 +12,21 @@ const (
 	OpNegate
 	OpNot
 	OpEqual
+	OpEqualInt
 	OpEqualString
 	OpJump
 	OpJumpIfTrue
 	OpJumpIfFalse
 	OpJumpBackward
 	OpIn
 	OpLess
+	OpLessInt
 	OpMore
+	OpMoreInt
 	OpLessOrEqual
+	OpLessOrEqualInt
 	OpMoreOrEqual
+	OpMoreOrEqualInt
 	OpAdd
 	OpSubtract
 	OpMultiply

vm/program.go

@@ -92,6 +92,9 @@ func (program *Program) Disassemble() string {
 		case OpEqual:
 			code("OpEqual")
 
+		case OpEqualInt:
+			code("OpEqualInt")
+
 		case OpEqualString:
 			code("OpEqualString")
 
@@ -113,15 +116,27 @@ func (program *Program) Disassemble() string {
 		case OpLess:
 			code("OpLess")
 
+		case OpLessInt:
+			code("OpLessInt")
+
 		case OpMore:
 			code("OpMore")
 
+		case OpMoreInt:
+			code("OpMoreInt")
+
 		case OpLessOrEqual:
 			code("OpLessOrEqual")
 
+		case OpLessOrEqualInt:
+			code("OpLessOrEqualInt")
+
 		case OpMoreOrEqual:
 			code("OpMoreOrEqual")
 
+		case OpMoreOrEqualInt:
+			code("OpMoreOrEqualInt")
+
 		case OpAdd:
 			code("OpAdd")
 

vm/runtime.go

@@ -177,40 +177,6 @@ func negate(i interface{}) interface{} {
 	}
 }
 
-func inc(i interface{}) interface{} {
-	switch v := i.(type) {
-	case float32:
-		return v + 1
-	case float64:
-		return v + 1
-
-	case int:
-		return v + 1
-	case int8:
-		return v + 1
-	case int16:
-		return v + 1
-	case int32:
-		return v + 1
-	case int64:
-		return v + 1
-
-	case uint:
-		return v + 1
-	case uint8:
-		return v + 1
-	case uint16:
-		return v + 1
-	case uint32:
-		return v + 1
-	case uint64:
-		return v + 1
-
-	default:
-		panic(fmt.Sprintf("invalid operation: %T + 1", v))
-	}
-}
-
 func exponent(a, b interface{}) float64 {
 	return math.Pow(toFloat64(a), toFloat64(b))
 }

vm/vm.go

@@ -112,6 +112,11 @@ func (vm *VM) Run() interface{} {
 			a := vm.pop()
 			vm.push(equal(a, b))
 
+		case OpEqualInt:
+			b := vm.pop()
+			a := vm.pop()
+			vm.push(a.(int) == b.(int))
+
 		case OpEqualString:
 			b := vm.pop()
 			a := vm.pop()
@@ -147,21 +152,41 @@ func (vm *VM) Run() interface{} {
 			a := vm.pop()
 			vm.push(less(a, b))
 
+		case OpLessInt:
+			b := vm.pop()
+			a := vm.pop()
+			vm.push(a.(int) < b.(int))
+
 		case OpMore:
 			b := vm.pop()
 			a := vm.pop()
 			vm.push(more(a, b))
 
+		case OpMoreInt:
+			b := vm.pop()
+			a := vm.pop()
+			vm.push(a.(int) > b.(int))
+
 		case OpLessOrEqual:
 			b := vm.pop()
 			a := vm.pop()
 			vm.push(lessOrEqual(a, b))
 
+		case OpLessOrEqualInt:
+			b := vm.pop()
+			a := vm.pop()
+			vm.push(a.(int) <= b.(int))
+
 		case OpMoreOrEqual:
 			b := vm.pop()
 			a := vm.pop()
 			vm.push(moreOrEqual(a, b))
 
+		case OpMoreOrEqualInt:
+			b := vm.pop()
+			a := vm.pop()
+			vm.push(a.(int) >= b.(int))
+
 		case OpAdd:
 			b := vm.pop()
 			a := vm.pop()