More strict in operator

Author: antonmedv

checker/checker.go

@@ -169,6 +169,9 @@ func (v *visitor) BinaryNode(node *ast.BinaryNode) reflect.Type {
 			return boolType
 		}
 		if isArray(r) || isMap(r) {
+			if isNumber(l) && isCertain(node.Left) && !isCertain(node.Right) {
+				setUncertainType(node.Right, dereference(l))
+			}
 			return boolType
 		}
 

compiler/compiler.go

@@ -68,8 +68,16 @@ func (c *compiler) emit(op byte, b ...byte) int {
 }
 
 func (c *compiler) makeConstant(i interface{}) []byte {
-	if p, ok := c.index[i]; ok {
-		return encode(p)
+	hashable := true
+	switch reflect.TypeOf(i).Kind() {
+	case reflect.Slice:
+		hashable = false
+	}
+
+	if hashable {
+		if p, ok := c.index[i]; ok {
+			return encode(p)
+		}
 	}
 
 	c.constants = append(c.constants, i)
@@ -78,7 +86,9 @@ func (c *compiler) makeConstant(i interface{}) []byte {
 	}
 
 	p := uint16(len(c.constants) - 1)
-	c.index[i] = p
+	if hashable {
+		c.index[i] = p
+	}
 	return encode(p)
 }
 
@@ -352,6 +362,40 @@ func (c *compiler) BinaryNode(node *ast.BinaryNode) {
 		c.emit(OpContains)
 
 	case "..":
+		min, ok1 := node.Left.(*ast.IntegerNode)
+		max, ok2 := node.Right.(*ast.IntegerNode)
+		if ok1 && ok2 {
+			// Create range on compile time to avoid unnecessary work at runtime.
+			size := max.Value - min.Value + 1
+			rng := make([]interface{}, size)
+			for i := range rng {
+				switch node.Left.GetType().Kind() {
+				case reflect.Int:
+					rng[i] = int(min.Value + i)
+				case reflect.Int8:
+					rng[i] = int8(min.Value + i)
+				case reflect.Int16:
+					rng[i] = int16(min.Value + i)
+				case reflect.Int32:
+					rng[i] = int32(min.Value + i)
+				case reflect.Int64:
+					rng[i] = int64(min.Value + i)
+
+				case reflect.Uint:
+					rng[i] = uint(min.Value + i)
+				case reflect.Uint8:
+					rng[i] = uint8(min.Value + i)
+				case reflect.Uint16:
+					rng[i] = uint16(min.Value + i)
+				case reflect.Uint32:
+					rng[i] = uint32(min.Value + i)
+				case reflect.Uint64:
+					rng[i] = uint64(min.Value + i)
+				}
+			}
+			c.emit(OpConst, c.makeConstant(rng)...)
+			return
+		}
 		c.compile(node.Left)
 		c.compile(node.Right)
 		c.emit(OpRange)

vm/runtime.go

@@ -91,7 +91,7 @@ func in(needle interface{}, array interface{}) bool {
 		for i := 0; i < v.Len(); i++ {
 			value := v.Index(i)
 			if value.IsValid() && value.CanInterface() {
-				if equalTypeIndependent(value.Interface(), needle) {
+				if equal(value.Interface(), needle) {
 					return true
 				}
 			}
@@ -212,43 +212,6 @@ func equal(a, b interface{}) bool {
 	}
 }
 
-func equalTypeIndependent(a, b interface{}) bool {
-	switch x := a.(type) {
-	case float32:
-		return x == float32(toFloat64(b))
-	case float64:
-		return x == float64(toFloat64(b))
-
-	case int:
-		return x == int(toFloat64(b))
-	case int8:
-		return x == int8(toFloat64(b))
-	case int16:
-		return x == int16(toFloat64(b))
-	case int32:
-		return x == int32(toFloat64(b))
-	case int64:
-		return x == int64(toFloat64(b))
-
-	case uint:
-		return x == uint(toFloat64(b))
-	case uint8:
-		return x == uint8(toFloat64(b))
-	case uint16:
-		return x == uint16(toFloat64(b))
-	case uint32:
-		return x == uint32(toFloat64(b))
-	case uint64:
-		return x == uint64(toFloat64(b))
-
-	case string:
-		return x == b.(string)
-
-	default:
-		return reflect.DeepEqual(a, b)
-	}
-}
-
 func less(a, b interface{}) interface{} {
 	switch x := a.(type) {
 	case float32:

vm/vm_test.go

@@ -188,6 +188,10 @@ func TestRun(t *testing.T) {
 			`1 in [1, 2, 3] && "foo" in {foo: 0, bar: 1} && "Price" in Ticket`,
 			true,
 		},
+		{
+			`1.5 in [1] && 1 in [1.5]`,
+			false,
+		},
 		{
 			`(true ? 0+1 : 2+3) + (false ? -1 : -2)`,
 			-1,