Merge branch 'master' into sum-predicate

Author: antonmedv

README.md

@@ -162,6 +162,7 @@ func main() {
 * [Visually.io](https://visually.io) employs Expr as a business rule engine for its personalization targeting algorithm.
 * [Akvorado](https://github.com/akvorado/akvorado) utilizes Expr to classify exporters and interfaces in network flows.
 * [keda.sh](https://keda.sh) uses Expr to allow customization of its Kubernetes-based event-driven autoscaling.
+* [Span Digital](https://spandigital.com/) uses Expr in it's Knowledge Management products.
 
 [Add your company too](https://github.com/expr-lang/expr/edit/master/README.md)
 

ast/print.go

@@ -202,5 +202,11 @@ func (n *MapNode) String() string {
 }
 
 func (n *PairNode) String() string {
-	return fmt.Sprintf("%s: %s", n.Key.String(), n.Value.String())
+	if str, ok := n.Key.(*StringNode); ok {
+		if utils.IsValidIdentifier(str.Value) {
+			return fmt.Sprintf("%s: %s", str.Value, n.Value.String())
+		}
+		return fmt.Sprintf("%q: %s", str.String(), n.Value.String())
+	}
+	return fmt.Sprintf("(%s): %s", n.Key.String(), n.Value.String())
 }

ast/print_test.go

@@ -55,8 +55,8 @@ func TestPrint(t *testing.T) {
 		{`func(a)`, `func(a)`},
 		{`func(a, b)`, `func(a, b)`},
 		{`{}`, `{}`},
-		{`{a: b}`, `{"a": b}`},
-		{`{a: b, c: d}`, `{"a": b, "c": d}`},
+		{`{a: b}`, `{a: b}`},
+		{`{a: b, c: d}`, `{a: b, c: d}`},
 		{`[]`, `[]`},
 		{`[a]`, `[a]`},
 		{`[a, b]`, `[a, b]`},
@@ -71,6 +71,7 @@ func TestPrint(t *testing.T) {
 		{`a[1:]`, `a[1:]`},
 		{`a[:]`, `a[:]`},
 		{`(nil ?? 1) > 0`, `(nil ?? 1) > 0`},
+		{`{("a" + "b"): 42}`, `{("a" + "b"): 42}`},
 	}
 
 	for _, tt := range tests {

builtin/builtin_test.go

@@ -608,3 +608,17 @@ func TestBuiltin_bitOpsFunc(t *testing.T) {
 		})
 	}
 }
+
+type customInt int
+
+func Test_int_unwraps_underlying_value(t *testing.T) {
+	env := map[string]any{
+		"customInt": customInt(42),
+	}
+	program, err := expr.Compile(`int(customInt) == 42`, expr.Env(env))
+	require.NoError(t, err)
+
+	out, err := expr.Run(program, env)
+	require.NoError(t, err)
+	assert.Equal(t, true, out)
+}

builtin/lib.go

@@ -209,6 +209,10 @@ func Int(x any) any {
 		}
 		return i
 	default:
+		val := reflect.ValueOf(x)
+		if val.CanConvert(integerType) {
+			return val.Convert(integerType).Interface()
+		}
 		panic(fmt.Sprintf("invalid operation: int(%T)", x))
 	}
 }

checker/checker_test.go

@@ -632,7 +632,7 @@ func TestCheck_TaggedFieldName(t *testing.T) {
 	tree, err := parser.Parse(`foo.bar`)
 	require.NoError(t, err)
 
-	config := &conf.Config{}
+	config := conf.CreateNew()
 	expr.Env(struct {
 		x struct {
 			y bool `expr:"bar"`

compiler/compiler.go

@@ -395,34 +395,12 @@ func (c *compiler) UnaryNode(node *ast.UnaryNode) {
 }
 
 func (c *compiler) BinaryNode(node *ast.BinaryNode) {
-	l := kind(node.Left)
-	r := kind(node.Right)
-
-	leftIsSimple := isSimpleType(node.Left)
-	rightIsSimple := isSimpleType(node.Right)
-	leftAndRightAreSimple := leftIsSimple && rightIsSimple
-
 	switch node.Operator {
 	case "==":
-		c.compile(node.Left)
-		c.derefInNeeded(node.Left)
-		c.compile(node.Right)
-		c.derefInNeeded(node.Right)
-
-		if l == r && l == reflect.Int && leftAndRightAreSimple {
-			c.emit(OpEqualInt)
-		} else if l == r && l == reflect.String && leftAndRightAreSimple {
-			c.emit(OpEqualString)
-		} else {
-			c.emit(OpEqual)
-		}
+		c.equalBinaryNode(node)
 
 	case "!=":
-		c.compile(node.Left)
-		c.derefInNeeded(node.Left)
-		c.compile(node.Right)
-		c.derefInNeeded(node.Right)
-		c.emit(OpEqual)
+		c.equalBinaryNode(node)
 		c.emit(OpNot)
 
 	case "or", "||":
@@ -580,6 +558,28 @@ func (c *compiler) BinaryNode(node *ast.BinaryNode) {
 	}
 }
 
+func (c *compiler) equalBinaryNode(node *ast.BinaryNode) {
+	l := kind(node.Left)
+	r := kind(node.Right)
+
+	leftIsSimple := isSimpleType(node.Left)
+	rightIsSimple := isSimpleType(node.Right)
+	leftAndRightAreSimple := leftIsSimple && rightIsSimple
+
+	c.compile(node.Left)
+	c.derefInNeeded(node.Left)
+	c.compile(node.Right)
+	c.derefInNeeded(node.Right)
+
+	if l == r && l == reflect.Int && leftAndRightAreSimple {
+		c.emit(OpEqualInt)
+	} else if l == r && l == reflect.String && leftAndRightAreSimple {
+		c.emit(OpEqualString)
+	} else {
+		c.emit(OpEqual)
+	}
+}
+
 func isSimpleType(node ast.Node) bool {
 	if node == nil {
 		return false

compiler/compiler_test.go

@@ -541,6 +541,39 @@ func TestCompile_optimizes_jumps(t *testing.T) {
 				{vm.OpFetch, 0},
 			},
 		},
+		{
+			`-1 not in [1, 2, 5]`,
+			[]op{
+				{vm.OpPush, 0},
+				{vm.OpPush, 1},
+				{vm.OpIn, 0},
+				{vm.OpNot, 0},
+			},
+		},
+		{
+			`1 + 8 not in [1, 2, 5]`,
+			[]op{
+				{vm.OpPush, 0},
+				{vm.OpPush, 1},
+				{vm.OpIn, 0},
+				{vm.OpNot, 0},
+			},
+		},
+		{
+			`true ? false : 8 not in [1, 2, 5]`,
+			[]op{
+				{vm.OpTrue, 0},
+				{vm.OpJumpIfFalse, 3},
+				{vm.OpPop, 0},
+				{vm.OpFalse, 0},
+				{vm.OpJump, 5},
+				{vm.OpPop, 0},
+				{vm.OpPush, 0},
+				{vm.OpPush, 1},
+				{vm.OpIn, 0},
+				{vm.OpNot, 0},
+			},
+		},
 	}
 
 	for _, test := range tests {

conf/config.go

@@ -32,6 +32,7 @@ type Config struct {
 func CreateNew() *Config {
 	c := &Config{
 		Optimize:  true,
+		Types:     make(TypesTable),
 		ConstFns:  make(map[string]reflect.Value),
 		Functions: make(map[string]*builtin.Function),
 		Builtins:  make(map[string]*builtin.Function),
@@ -62,7 +63,10 @@ func (c *Config) WithEnv(env any) {
 	}
 
 	c.Env = env
-	c.Types = CreateTypesTable(env)
+	types := CreateTypesTable(env)
+	for name, t := range types {
+		c.Types[name] = t
+	}
 	c.MapEnv = mapEnv
 	c.DefaultType = mapValueType
 	c.Strict = true