Merge branch 'master' into feat/bytes-node

Author: antonmedv

README.md

@@ -1,8 +1,5 @@
 <h1><a href="https://expr-lang.org"><img src="https://expr-lang.org/img/logo.png" alt="Zx logo" height="48"align="right"></a> Expr</h1>
 
-> [!IMPORTANT]
-> The repository [github.com/antonmedv/expr](https://github.com/antonmedv/expr) moved to [github.com/**expr-lang**/expr](https://github.com/expr-lang/expr).
-
 [![test](https://github.com/expr-lang/expr/actions/workflows/test.yml/badge.svg)](https://github.com/expr-lang/expr/actions/workflows/test.yml) 
 [![Go Report Card](https://goreportcard.com/badge/github.com/expr-lang/expr)](https://goreportcard.com/report/github.com/expr-lang/expr) 
 [![Fuzzing Status](https://oss-fuzz-build-logs.storage.googleapis.com/badges/expr.svg)](https://bugs.chromium.org/p/oss-fuzz/issues/list?sort=-opened&can=1&q=proj:expr)

optimizer/count_any.go

@@ -0,0 +1,36 @@
+package optimizer
+
+import (
+	. "github.com/expr-lang/expr/ast"
+)
+
+// countAny optimizes count comparisons to use any for early termination.
+// Patterns:
+//   - count(arr, pred) > 0  → any(arr, pred)
+//   - count(arr, pred) >= 1 → any(arr, pred)
+type countAny struct{}
+
+func (*countAny) Visit(node *Node) {
+	binary, ok := (*node).(*BinaryNode)
+	if !ok {
+		return
+	}
+
+	count, ok := binary.Left.(*BuiltinNode)
+	if !ok || count.Name != "count" || len(count.Arguments) != 2 {
+		return
+	}
+
+	integer, ok := binary.Right.(*IntegerNode)
+	if !ok {
+		return
+	}
+
+	if (binary.Operator == ">" && integer.Value == 0) ||
+		(binary.Operator == ">=" && integer.Value == 1) {
+		patchCopyType(node, &BuiltinNode{
+			Name:      "any",
+			Arguments: count.Arguments,
+		})
+	}
+}

optimizer/count_any_test.go

@@ -0,0 +1,166 @@
+package optimizer_test
+
+import (
+	"testing"
+
+	"github.com/expr-lang/expr"
+	. "github.com/expr-lang/expr/ast"
+	"github.com/expr-lang/expr/internal/testify/assert"
+	"github.com/expr-lang/expr/internal/testify/require"
+	"github.com/expr-lang/expr/optimizer"
+	"github.com/expr-lang/expr/parser"
+	"github.com/expr-lang/expr/vm"
+)
+
+func TestOptimize_count_any(t *testing.T) {
+	tree, err := parser.Parse(`count(items, .active) > 0`)
+	require.NoError(t, err)
+
+	err = optimizer.Optimize(&tree.Node, nil)
+	require.NoError(t, err)
+
+	expected := &BuiltinNode{
+		Name: "any",
+		Arguments: []Node{
+			&IdentifierNode{Value: "items"},
+			&PredicateNode{
+				Node: &MemberNode{
+					Node:     &PointerNode{},
+					Property: &StringNode{Value: "active"},
+				},
+			},
+		},
+	}
+
+	assert.Equal(t, Dump(expected), Dump(tree.Node))
+}
+
+func TestOptimize_count_any_gte_one(t *testing.T) {
+	tree, err := parser.Parse(`count(items, .valid) >= 1`)
+	require.NoError(t, err)
+
+	err = optimizer.Optimize(&tree.Node, nil)
+	require.NoError(t, err)
+
+	expected := &BuiltinNode{
+		Name: "any",
+		Arguments: []Node{
+			&IdentifierNode{Value: "items"},
+			&PredicateNode{
+				Node: &MemberNode{
+					Node:     &PointerNode{},
+					Property: &StringNode{Value: "valid"},
+				},
+			},
+		},
+	}
+
+	assert.Equal(t, Dump(expected), Dump(tree.Node))
+}
+
+func TestOptimize_count_any_correctness(t *testing.T) {
+	tests := []struct {
+		expr string
+		want bool
+	}{
+		// count > 0 → any
+		{`count(1..100, # == 1) > 0`, true},
+		{`count(1..100, # == 50) > 0`, true},
+		{`count(1..100, # == 100) > 0`, true},
+		{`count(1..100, # == 0) > 0`, false},
+
+		// count >= 1 → any
+		{`count(1..100, # % 10 == 0) >= 1`, true},
+		{`count(1..100, # > 100) >= 1`, false},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.expr, func(t *testing.T) {
+			program, err := expr.Compile(tt.expr)
+			require.NoError(t, err)
+
+			output, err := expr.Run(program, nil)
+			require.NoError(t, err)
+			assert.Equal(t, tt.want, output)
+		})
+	}
+}
+
+func TestOptimize_count_no_optimization(t *testing.T) {
+	// These should NOT be optimized
+	tests := []string{
+		`count(items, .active) > 1`,  // not > 0
+		`count(items, .active) >= 2`, // not >= 1
+		`count(items, .active) == 0`, // not optimized (none has overhead)
+		`count(items, .active) == 1`, // not == 0
+		`count(items, .active) < 1`,  // not optimized (none has overhead)
+		`count(items, .active) <= 0`, // not optimized (none has overhead)
+		`count(items, .active) != 0`, // different operator
+	}
+
+	for _, code := range tests {
+		t.Run(code, func(t *testing.T) {
+			tree, err := parser.Parse(code)
+			require.NoError(t, err)
+
+			err = optimizer.Optimize(&tree.Node, nil)
+			require.NoError(t, err)
+
+			// Should still be a BinaryNode (not optimized to any)
+			_, ok := tree.Node.(*BinaryNode)
+			assert.True(t, ok, "expected BinaryNode, got %T", tree.Node)
+		})
+	}
+}
+
+// Benchmarks for count > 0 → any
+func BenchmarkCountGtZero(b *testing.B) {
+	program, _ := expr.Compile(`count(1..1000, # == 1) > 0`)
+	var out any
+	b.ResetTimer()
+	for n := 0; n < b.N; n++ {
+		out, _ = vm.Run(program, nil)
+	}
+	_ = out
+}
+
+func BenchmarkCountGtZeroLargeEarlyMatch(b *testing.B) {
+	program, _ := expr.Compile(`count(1..10000, # == 1) > 0`)
+	var out any
+	b.ResetTimer()
+	for n := 0; n < b.N; n++ {
+		out, _ = vm.Run(program, nil)
+	}
+	_ = out
+}
+
+func BenchmarkCountGtZeroNoMatch(b *testing.B) {
+	program, _ := expr.Compile(`count(1..1000, # == 0) > 0`)
+	var out any
+	b.ResetTimer()
+	for n := 0; n < b.N; n++ {
+		out, _ = vm.Run(program, nil)
+	}
+	_ = out
+}
+
+// Benchmarks for count >= 1 → any
+func BenchmarkCountGteOneEarlyMatch(b *testing.B) {
+	program, _ := expr.Compile(`count(1..1000, # == 1) >= 1`)
+	var out any
+	b.ResetTimer()
+	for n := 0; n < b.N; n++ {
+		out, _ = vm.Run(program, nil)
+	}
+	_ = out
+}
+
+func BenchmarkCountGteOneNoMatch(b *testing.B) {
+	program, _ := expr.Compile(`count(1..1000, # == 0) >= 1`)
+	var out any
+	b.ResetTimer()
+	for n := 0; n < b.N; n++ {
+		out, _ = vm.Run(program, nil)
+	}
+	_ = out
+}

optimizer/optimizer.go

@@ -40,8 +40,10 @@ func Optimize(node *Node, config *conf.Config) error {
 	Walk(node, &filterLast{})
 	Walk(node, &filterFirst{})
 	Walk(node, &predicateCombination{})
+	Walk(node, &sumRange{})
 	Walk(node, &sumArray{})
 	Walk(node, &sumMap{})
+	Walk(node, &countAny{})
 	return nil
 }
 

optimizer/sum_range.go

@@ -0,0 +1,172 @@
+package optimizer
+
+import (
+	. "github.com/expr-lang/expr/ast"
+)
+
+type sumRange struct{}
+
+func (*sumRange) Visit(node *Node) {
+	// Pattern 1: sum(m..n) or sum(m..n, predicate) where m and n are constant integers
+	if sumBuiltin, ok := (*node).(*BuiltinNode); ok &&
+		sumBuiltin.Name == "sum" &&
+		(len(sumBuiltin.Arguments) == 1 || len(sumBuiltin.Arguments) == 2) {
+		if rangeOp, ok := sumBuiltin.Arguments[0].(*BinaryNode); ok && rangeOp.Operator == ".." {
+			if from, ok := rangeOp.Left.(*IntegerNode); ok {
+				if to, ok := rangeOp.Right.(*IntegerNode); ok {
+					m := from.Value
+					n := to.Value
+					if n >= m {
+						count := n - m + 1
+						// Use the arithmetic series formula: (n - m + 1) * (m + n) / 2
+						sum := count * (m + n) / 2
+
+						if len(sumBuiltin.Arguments) == 1 {
+							// sum(m..n)
+							patchWithType(node, &IntegerNode{Value: sum})
+						} else if len(sumBuiltin.Arguments) == 2 {
+							// sum(m..n, predicate)
+							if result, ok := applySumPredicate(sum, count, sumBuiltin.Arguments[1]); ok {
+								patchWithType(node, &IntegerNode{Value: result})
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+
+	// Pattern 2: reduce(m..n, # + #acc) where m and n are constant integers
+	if reduceBuiltin, ok := (*node).(*BuiltinNode); ok &&
+		reduceBuiltin.Name == "reduce" &&
+		(len(reduceBuiltin.Arguments) == 2 || len(reduceBuiltin.Arguments) == 3) {
+		if rangeOp, ok := reduceBuiltin.Arguments[0].(*BinaryNode); ok && rangeOp.Operator == ".." {
+			if from, ok := rangeOp.Left.(*IntegerNode); ok {
+				if to, ok := rangeOp.Right.(*IntegerNode); ok {
+					if isPointerPlusAcc(reduceBuiltin.Arguments[1]) {
+						m := from.Value
+						n := to.Value
+						if n >= m {
+							// Use the arithmetic series formula: (n - m + 1) * (m + n) / 2
+							sum := (n - m + 1) * (m + n) / 2
+
+							// Check for optional initialValue (3rd argument)
+							if len(reduceBuiltin.Arguments) == 3 {
+								if initialValue, ok := reduceBuiltin.Arguments[2].(*IntegerNode); ok {
+									result := initialValue.Value + sum
+									patchWithType(node, &IntegerNode{Value: result})
+								}
+							} else {
+								patchWithType(node, &IntegerNode{Value: sum})
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+// isPointerPlusAcc checks if the node represents `# + #acc` pattern
+func isPointerPlusAcc(node Node) bool {
+	predicate, ok := node.(*PredicateNode)
+	if !ok {
+		return false
+	}
+
+	binary, ok := predicate.Node.(*BinaryNode)
+	if !ok {
+		return false
+	}
+
+	if binary.Operator != "+" {
+		return false
+	}
+
+	// Check for # + #acc (pointer + accumulator)
+	leftPointer, leftIsPointer := binary.Left.(*PointerNode)
+	rightPointer, rightIsPointer := binary.Right.(*PointerNode)
+
+	if leftIsPointer && rightIsPointer {
+		// # + #acc: Left is pointer (Name=""), Right is acc (Name="acc")
+		if leftPointer.Name == "" && rightPointer.Name == "acc" {
+			return true
+		}
+		// #acc + #: Left is acc (Name="acc"), Right is pointer (Name="")
+		if leftPointer.Name == "acc" && rightPointer.Name == "" {
+			return true
+		}
+	}
+
+	return false
+}
+
+// applySumPredicate tries to compute the result of sum(m..n, predicate) at compile time.
+// Returns (result, true) if optimization is possible, (0, false) otherwise.
+// Supported predicates:
+//   - # (identity): result = sum
+//   - # * k (multiply by constant): result = k * sum
+//   - k * # (multiply by constant): result = k * sum
+//   - # + k (add constant): result = sum + count * k
+//   - k + # (add constant): result = sum + count * k
+//   - # - k (subtract constant): result = sum - count * k
+func applySumPredicate(sum, count int, predicateArg Node) (int, bool) {
+	predicate, ok := predicateArg.(*PredicateNode)
+	if !ok {
+		return 0, false
+	}
+
+	// Case 1: # (identity) - just return the sum
+	if pointer, ok := predicate.Node.(*PointerNode); ok && pointer.Name == "" {
+		return sum, true
+	}
+
+	// Case 2: Binary operations with pointer and constant
+	binary, ok := predicate.Node.(*BinaryNode)
+	if !ok {
+		return 0, false
+	}
+
+	pointer, constant, pointerOnLeft := extractPointerAndConstantWithPosition(binary)
+	if pointer == nil || constant == nil {
+		return 0, false
+	}
+
+	switch binary.Operator {
+	case "*":
+		// # * k or k * # => k * sum
+		return constant.Value * sum, true
+	case "+":
+		// # + k or k + # => sum + count * k
+		return sum + count*constant.Value, true
+	case "-":
+		if pointerOnLeft {
+			// # - k => sum - count * k
+			return sum - count*constant.Value, true
+		}
+		// k - # => count * k - sum
+		return count*constant.Value - sum, true
+	}
+
+	return 0, false
+}
+
+// extractPointerAndConstantWithPosition extracts pointer (#) and integer constant from a binary node.
+// Returns (pointer, constant, pointerOnLeft) or (nil, nil, false) if not matching the expected pattern.
+func extractPointerAndConstantWithPosition(binary *BinaryNode) (*PointerNode, *IntegerNode, bool) {
+	// Try left=pointer, right=constant
+	if pointer, ok := binary.Left.(*PointerNode); ok && pointer.Name == "" {
+		if constant, ok := binary.Right.(*IntegerNode); ok {
+			return pointer, constant, true
+		}
+	}
+
+	// Try left=constant, right=pointer
+	if constant, ok := binary.Left.(*IntegerNode); ok {
+		if pointer, ok := binary.Right.(*PointerNode); ok && pointer.Name == "" {
+			return pointer, constant, false
+		}
+	}
+
+	return nil, nil, false
+}