feat: use types provided in Function to discriminate proper operator overload

Author: nikolaymatrosov

conf/operators.go

@@ -13,30 +13,40 @@ type OperatorsTable map[string][]string
 func FindSuitableOperatorOverload(fns []string, types TypesTable, l, r reflect.Type) (reflect.Type, string, bool) {
 	for _, fn := range fns {
 		fnType := types[fn]
+
 		firstInIndex := 0
 		if fnType.Method {
 			firstInIndex = 1 // As first argument to method is receiver.
 		}
-		var firstArgType reflect.Type
-		var secondArgType reflect.Type
-
-		if fnType.Type.NumIn() == 1 && fnType.Type.In(0).Kind() == reflect.Slice {
-			firstArgType = fnType.Type.In(0).Elem()
-			secondArgType = fnType.Type.In(0).Elem()
+		if fnType.Overloads != nil {
+			for _, overload := range fnType.Overloads {
+				ret, done := checkType(overload, l, r, firstInIndex)
+				if done {
+					return ret, fn, true
+				}
+			}
 		} else {
-			firstArgType = fnType.Type.In(firstInIndex)
-			secondArgType = fnType.Type.In(firstInIndex + 1)
-		}
-
-		firstArgumentFit := l == firstArgType || (firstArgType.Kind() == reflect.Interface && (l == nil || l.Implements(firstArgType)))
-		secondArgumentFit := r == secondArgType || (secondArgType.Kind() == reflect.Interface && (r == nil || r.Implements(secondArgType)))
-		if firstArgumentFit && secondArgumentFit {
-			return fnType.Type.Out(0), fn, true
+			ret, done := checkType(fnType.Type, l, r, firstInIndex)
+			if done {
+				return ret, fn, true
+			}
 		}
 	}
 	return nil, "", false
 }
 
+func checkType(t reflect.Type, l reflect.Type, r reflect.Type, firstInIndex int) (reflect.Type, bool) {
+	firstArgType := t.In(firstInIndex)
+	secondArgType := t.In(firstInIndex + 1)
+
+	firstArgumentFit := l == firstArgType || (firstArgType.Kind() == reflect.Interface && (l == nil || l.Implements(firstArgType)))
+	secondArgumentFit := r == secondArgType || (secondArgType.Kind() == reflect.Interface && (r == nil || r.Implements(secondArgType)))
+	if firstArgumentFit && secondArgumentFit {
+		return t.Out(0), true
+	}
+	return nil, false
+}
+
 type OperatorPatcher struct {
 	Operators OperatorsTable
 	Types     TypesTable

conf/types_table.go

@@ -10,6 +10,7 @@ type Tag struct {
 	FieldIndex  []int
 	Method      bool
 	MethodIndex int
+	Overloads   []reflect.Type
 }
 
 type TypesTable map[string]Tag

expr.go

@@ -128,7 +128,8 @@ func Function(name string, fn func(params ...interface{}) (interface{}, error),
 			Types: ts,
 		}
 		c.Types[name] = conf.Tag{
-			Type: reflect.TypeOf(fn),
+			Type:      reflect.TypeOf(fn),
+			Overloads: ts,
 		}
 	}
 }

test/operator/operator_test.go

@@ -1,6 +1,7 @@
 package operator_test
 
 import (
+	"fmt"
 	"testing"
 	"time"
 
@@ -65,19 +66,43 @@ func TestOperator_Function(t *testing.T) {
 		"bar": Value{2},
 	}
 
-	program, err := expr.Compile(
-		`foo + bar`,
-		expr.Env(env),
-		expr.Operator("+", "Add"),
-		expr.Function("Add", func(args ...interface{}) (interface{}, error) {
-			return args[0].(Value).Int + args[1].(Value).Int, nil
+	tests := []struct {
+		input string
+		want  int
+	}{
+		{
+			input: `foo + bar`,
+			want:  3,
 		},
-			new(func(_ Value, __ Value) int),
-		),
-	)
-	require.NoError(t, err)
+		{
+			input: `2 + 4`,
+			want:  6,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(fmt.Sprintf(`opertor function helper test %s`, tt.input), func(t *testing.T) {
+			program, err := expr.Compile(
+				tt.input,
+				expr.Env(env),
+				expr.Operator("+", "Add", "AddInt"),
+				expr.Function("Add", func(args ...interface{}) (interface{}, error) {
+					return args[0].(Value).Int + args[1].(Value).Int, nil
+				},
+					new(func(_ Value, __ Value) int),
+				),
+				expr.Function("AddInt", func(args ...interface{}) (interface{}, error) {
+					return args[0].(int) + args[1].(int), nil
+				},
+					new(func(_ int, __ int) int),
+				),
+			)
+			require.NoError(t, err)
+
+			output, err := expr.Run(program, env)
+			require.NoError(t, err)
+			require.Equal(t, tt.want, output)
+		})
+	}
 
-	output, err := expr.Run(program, env)
-	require.NoError(t, err)
-	require.Equal(t, 3, output)
 }