Fix operator overloading recursive

Fixes #548

expr.go

@@ -200,11 +200,24 @@ func Compile(input string, ops ...Option) (*vm.Program, error) {
  }
 
  if len(config.Visitors) > 0 {
- for _, v := range config.Visitors {
- // We need to perform types check, because some visitors may rely on
- // types information available in the tree.
- _, _ = checker.Check(tree, config)
- ast.Walk(&tree.Node, v)
+ for i := 0; i < 1000; i++ {
+ more := false
+ for _, v := range config.Visitors {
+ // We need to perform types check, because some visitors may rely on
+ // types information available in the tree.
+ _, _ = checker.Check(tree, config)
+
+ ast.Walk(&tree.Node, v)
+
+ if v, ok := v.(interface {
+ ShouldRepeat() bool
+ }); ok {
+ more = more || v.ShouldRepeat()
+ }
+ }
+ if !more {
+ break
+ }
  }
  }
  _, err = checker.Check(tree, config)

patcher/operator_override.go

@@ -14,6 +14,7 @@ type OperatorOverride struct {
  Overrides []string // List of function names to override operator with.
  Types conf.TypesTable // Env types.
  Functions conf.FunctionsTable // Env functions.
+ applied bool // Flag to indicate if any override was applied.
 }
 
 func (p *OperatorOverride) Visit(node *ast.Node) {
@@ -37,9 +38,14 @@ func (p *OperatorOverride) Visit(node *ast.Node) {
  }
  newNode.SetType(ret)
  ast.Patch(node, newNode)
+ p.applied = true
  }
 }
 
+func (p *OperatorOverride) ShouldRepeat() bool {
+ return p.applied
+}
+
 func (p *OperatorOverride) FindSuitableOperatorOverload(l, r reflect.Type) (reflect.Type, string, bool) {
  t, fn, ok := p.findSuitableOperatorOverloadInFunctions(l, r)
  if !ok {

test/operator/issues584/issues584_test.go

@@ -0,0 +1,73 @@
+package issues584_test
+
+import (
+ "testing"
+
+ "github.com/stretchr/testify/assert"
+
+ "github.com/expr-lang/expr"
+)
+
+type Env struct{}
+
+type Program struct {
+}
+
+func (p *Program) Foo() Value {
+ return func(e *Env) float64 {
+ return 5
+ }
+}
+
+func (p *Program) Bar() Value {
+ return func(e *Env) float64 {
+ return 100
+ }
+}
+
+func (p *Program) AndCondition(a, b Condition) Conditions {
+ return Conditions{a, b}
+}
+
+func (p *Program) AndConditions(a Conditions, b Condition) Conditions {
+ return append(a, b)
+}
+
+func (p *Program) ValueGreaterThan_float(v Value, i float64) Condition {
+ return func(e *Env) bool {
+ realized := v(e)
+ return realized > i
+ }
+}
+
+func (p *Program) ValueLessThan_float(v Value, i float64) Condition {
+ return func(e *Env) bool {
+ realized := v(e)
+ return realized < i
+ }
+}
+
+type Condition func(e *Env) bool
+type Conditions []Condition
+
+type Value func(e *Env) float64
+
+func TestIssue584(t *testing.T) {
+ code := `Foo() > 1.5 and Bar() < 200.0`
+
+ p := &Program{}
+
+ opt := []expr.Option{
+ expr.Env(p),
+ expr.Operator("and", "AndCondition", "AndConditions"),
+ expr.Operator(">", "ValueGreaterThan_float"),
+ expr.Operator("<", "ValueLessThan_float"),
+ }
+
+ program, err := expr.Compile(code, opt...)
+ assert.Nil(t, err)
+
+ state, err := expr.Run(program, p)
+ assert.Nil(t, err)
+ assert.NotNil(t, state)
+}

test/operator/operator_test.go

@@ -216,3 +216,40 @@ func TestOperator_Polymorphic(t *testing.T) {
  require.NoError(t, err)
  require.Equal(t, 6, output)
 }
+
+func TestOperator_recursive_apply(t *testing.T) {
+ type Decimal struct {
+ Int int
+ }
+
+ env := map[string]any{
+ "add": func(a, b Decimal) Decimal {
+ return Decimal{
+ Int: a.Int + b.Int,
+ }
+ },
+ "addInt": func(a Decimal, b int) Decimal {
+ return Decimal{
+ Int: a.Int + b,
+ }
+ },
+ "a": Decimal{1},
+ "b": Decimal{2},
+ "c": Decimal{3},
+ "d": Decimal{4},
+ "e": Decimal{5},
+ }
+
+ program, err := expr.Compile(
+ `a + b + 100 + c + d + e`,
+ expr.Env(env),
+ expr.Operator("+", "add"),
+ expr.Operator("+", "addInt"),
+ )
+ require.NoError(t, err)
+ require.Equal(t, `add(add(add(addInt(add(a, b), 100), c), d), e)`, program.Node().String())
+
+ output, err := expr.Run(program, env)
+ require.NoError(t, err)
+ require.Equal(t, 115, output.(Decimal).Int)
+}