Merge branch 'master' into perf/scope-pooling

antonmedv · web-flow · commit 11c895170478 · 2026-02-14T13:21:35.000+01:00
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
@@ -11,7 +11,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        go-versions: [ '1.18', '1.22', '1.24', '1.25' ]
+        go-versions: [ '1.18', '1.22', '1.24', '1.25', '1.26' ]
         go-arch: [ '386' ]
     steps:
       - uses: actions/checkout@v3
diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
@@ -11,7 +11,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        go-versions: [ '1.18', '1.19', '1.20', '1.21', '1.22', '1.23', '1.24', '1.25' ]
+        go-versions: [ '1.18', '1.19', '1.20', '1.21', '1.22', '1.23', '1.24', '1.25', '1.26' ]
     steps:
       - uses: actions/checkout@v3
       - name: Setup Go ${{ matrix.go-version }}
diff --git a/README.md b/README.md
@@ -170,6 +170,7 @@ func main() {
 * [WunderGraph Cosmo](https://github.com/wundergraph/cosmo) - GraphQL Federeration Router uses Expr to customize Middleware behaviour
 * [SOLO](https://solo.one) uses Expr interally to allow dynamic code execution with custom defined functions.
 * [Naoma.AI](https://www.naoma.ai) uses Expr as a part of its call scoring engine.
+* [GlassFlow.dev](https://github.com/glassflow/clickhouse-etl) uses Expr to do realtime data transformation in ETL pipelines
 
 [Add your company too](https://github.com/expr-lang/expr/edit/master/README.md)
 
diff --git a/builtin/builtin_test.go b/builtin/builtin_test.go
@@ -283,6 +283,7 @@ func TestBuiltin_errors(t *testing.T) {
 		{`timezone(nil)`, "cannot use nil as argument (type string) to call timezone (1:10)"},
 		{`flatten([1, 2], [3, 4])`, "invalid number of arguments (expected 1, got 2)"},
 		{`flatten(1)`, "cannot flatten int"},
+		{`fromJSON("5e2482")`, "cannot unmarshal number"},
 	}
 	for _, test := range errorTests {
 		t.Run(test.input, func(t *testing.T) {
@@ -299,6 +300,15 @@ func TestBuiltin_errors(t *testing.T) {
 	}
 }
 
+func TestBuiltin_env_not_callable(t *testing.T) {
+	code := `$env(''matches'i'?t:get().UTC())`
+	env := map[string]any{"t": 1}
+
+	_, err := expr.Compile(code, expr.Env(env))
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "is not callable")
+}
+
 func TestBuiltin_types(t *testing.T) {
 	env := map[string]any{
 		"num":           42,
diff --git a/builtin/lib.go b/builtin/lib.go
@@ -564,6 +564,9 @@ func flatten(arg reflect.Value, depth int) ([]any, error) {
 }
 
 func get(params ...any) (out any, err error) {
+	if len(params) < 2 {
+		return nil, fmt.Errorf("invalid number of arguments (expected 2, got %d)", len(params))
+	}
 	from := params[0]
 	i := params[1]
 	v := reflect.ValueOf(from)
diff --git a/checker/checker.go b/checker/checker.go
@@ -651,6 +651,11 @@ func (v *Checker) callNode(node *ast.CallNode) Nature {
 		return *node.Nature()
 	}
 
+	// $env is not callable.
+	if id, ok := node.Callee.(*ast.IdentifierNode); ok && id.Value == "$env" {
+		return v.error(node, "%s is not callable", v.config.Env.String())
+	}
+
 	nt := v.visit(node.Callee)
 	if nt.IsUnknown(&v.config.NtCache) {
 		return Nature{}
diff --git a/checker/checker_test.go b/checker/checker_test.go
@@ -681,6 +681,30 @@ invalid operation: > (mismatched types string and int) (1:30)
 invalid operation: + (mismatched types int and bool) (1:6)
  | 1; 2 + true; 3
  | .....^
+`,
+		},
+		{
+			`$env()`,
+			`
+mock.Env is not callable (1:1)
+ | $env()
+ | ^
+`,
+		},
+		{
+			`$env(1)`,
+			`
+mock.Env is not callable (1:1)
+ | $env(1)
+ | ^
+`,
+		},
+		{
+			`$env(abs())`,
+			`
+mock.Env is not callable (1:1)
+ | $env(abs())
+ | ^
 `,
 		},
 	}
diff --git a/expr.go b/expr.go
@@ -195,9 +195,14 @@ func EnableBuiltin(name string) Option {
 
 // WithContext passes context to all functions calls with a context.Context argument.
 func WithContext(name string) Option {
-	return Patch(patcher.WithContext{
-		Name: name,
-	})
+	return func(c *conf.Config) {
+		c.Visitors = append(c.Visitors, patcher.WithContext{
+			Name:      name,
+			Functions: c.Functions,
+			Env:       &c.Env,
+			NtCache:   &c.NtCache,
+		})
+	}
 }
 
 // Timezone sets default timezone for date() and now() builtin functions.
diff --git a/parser/parser.go b/parser/parser.go
@@ -575,10 +575,7 @@ func (p *Parser) parseCall(token Token, arguments []Node, checkOverrides bool) N
 	}
 	isOverridden = isOverridden && checkOverrides
 
-	if _, ok := predicates[token.Value]; ok && p.config != nil && p.config.Disabled[token.Value] && !isOverridden {
-		// Disabled predicate without replacement - fail immediately
-		p.error("unknown name %s", token.Value)
-	} else if b, ok := predicates[token.Value]; ok && !isOverridden {
+	if b, ok := predicates[token.Value]; ok && !isOverridden {
 		p.expect(Bracket, "(")
 
 		// In case of the pipe operator, the first argument is the left-hand side
@@ -622,9 +619,6 @@ func (p *Parser) parseCall(token Token, arguments []Node, checkOverrides bool) N
 		if node == nil {
 			return nil
 		}
-	} else if _, ok := builtin.Index[token.Value]; ok && p.config != nil && p.config.Disabled[token.Value] && !isOverridden {
-		// Disabled builtin without replacement - fail immediately
-		p.error("unknown name %s", token.Value)
 	} else if _, ok := builtin.Index[token.Value]; ok && (p.config == nil || !p.config.Disabled[token.Value]) && !isOverridden {
 		node = p.createNode(&BuiltinNode{
 			Name:      token.Value,
diff --git a/patcher/with_context.go b/patcher/with_context.go
@@ -4,11 +4,16 @@ import (
 	"reflect"
 
 	"github.com/expr-lang/expr/ast"
+	"github.com/expr-lang/expr/checker/nature"
+	"github.com/expr-lang/expr/conf"
 )
 
 // WithContext adds WithContext.Name argument to all functions calls with a context.Context argument.
 type WithContext struct {
-	Name string
+	Name      string
+	Functions conf.FunctionsTable // Optional: used to look up function types when callee type is unknown.
+	Env       *nature.Nature      // Optional: used to look up method types when callee type is unknown.
+	NtCache   *nature.Cache       // Optional: cache for nature lookups.
 }
 
 // Visit adds WithContext.Name argument to all functions calls with a context.Context argument.
@@ -19,6 +24,24 @@ func (w WithContext) Visit(node *ast.Node) {
 		if fn == nil {
 			return
 		}
+		// If callee type is interface{} (unknown), look up the function type from
+		// the Functions table or Env. This handles cases where the checker returns early
+		// without visiting nested call arguments (e.g., Date2() in Now2().After(Date2()))
+		// because the outer call's type is unknown due to missing context arguments.
+		if fn.Kind() == reflect.Interface {
+			if ident, ok := call.Callee.(*ast.IdentifierNode); ok {
+				if w.Functions != nil {
+					if f, ok := w.Functions[ident.Value]; ok {
+						fn = f.Type()
+					}
+				}
+				if fn.Kind() == reflect.Interface && w.Env != nil {
+					if m, ok := w.Env.MethodByName(w.NtCache, ident.Value); ok {
+						fn = m.Type
+					}
+				}
+			}
+		}
 		if fn.Kind() != reflect.Func {
 			return
 		}
diff --git a/test/fuzz/fuzz_corpus.txt b/test/fuzz/fuzz_corpus.txt
@@ -19543,3 +19543,4 @@ values({"foo": ok})
 {"foo": score, "foo": array}.array
 {"foo": score, "foo": f32}
 {"foo": score, "foo": greet}
+fromJSON('5e2482')
diff --git a/test/fuzz/fuzz_test.go b/test/fuzz/fuzz_test.go
@@ -36,11 +36,14 @@ func FuzzExpr(f *testing.F) {
 		regexp.MustCompile(`unknown time zone`),
 		regexp.MustCompile(`invalid location name`),
 		regexp.MustCompile(`json: unsupported value`),
+		regexp.MustCompile(`json: unsupported type`),
+		regexp.MustCompile(`json: cannot unmarshal .* into Go value of type .*`),
 		regexp.MustCompile(`unexpected end of JSON input`),
 		regexp.MustCompile(`memory budget exceeded`),
 		regexp.MustCompile(`using interface \{} as type .*`),
 		regexp.MustCompile(`reflect.Value.MapIndex: value of type .* is not assignable to type .*`),
 		regexp.MustCompile(`reflect: Call using .* as type .*`),
+		regexp.MustCompile(`reflect: cannot use .* as type .* in .*`),
 		regexp.MustCompile(`reflect: Call with too few input arguments`),
 		regexp.MustCompile(`invalid number of arguments`),
 		regexp.MustCompile(`reflect: call of reflect.Value.Call on .* Value`),
diff --git a/test/issues/823/issue_test.go b/test/issues/823/issue_test.go
@@ -2,7 +2,6 @@ package issue_test
 
 import (
 	"context"
-	"fmt"
 	"testing"
 	"time"
 
@@ -14,26 +13,72 @@ type env struct {
 	Ctx context.Context `expr:"ctx"`
 }
 
+// TestIssue823 verifies that WithContext injects context into nested custom
+// function calls. The bug was that date2() nested as an argument to After()
+// didn't receive the context because its callee type was unknown.
 func TestIssue823(t *testing.T) {
+	now2Called := false
+	date2Called := false
+
 	p, err := expr.Compile(
 		"now2().After(date2())",
 		expr.Env(env{}),
 		expr.WithContext("ctx"),
 		expr.Function(
 			"now2",
-			func(params ...any) (any, error) { return time.Now(), nil },
+			func(params ...any) (any, error) {
+				require.Len(t, params, 1, "now2 should receive context")
+				_, ok := params[0].(context.Context)
+				require.True(t, ok, "now2 first param should be context.Context")
+				now2Called = true
+				return time.Now(), nil
+			},
 			new(func(context.Context) time.Time),
 		),
 		expr.Function(
 			"date2",
-			func(params ...any) (any, error) { return time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC), nil },
+			func(params ...any) (any, error) {
+				require.Len(t, params, 1, "date2 should receive context")
+				_, ok := params[0].(context.Context)
+				require.True(t, ok, "date2 first param should be context.Context")
+				date2Called = true
+				return time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC), nil
+			},
 			new(func(context.Context) time.Time),
 		),
 	)
-	fmt.Printf("Compile result err: %v\n", err)
 	require.NoError(t, err)
 
 	r, err := expr.Run(p, &env{Ctx: context.Background()})
 	require.NoError(t, err)
 	require.True(t, r.(bool))
+	require.True(t, now2Called, "now2 should have been called")
+	require.True(t, date2Called, "date2 should have been called")
+}
+
+// envWithMethods tests that Env methods with context.Context work correctly
+// when nested in method chains (similar to TestIssue823 but with Env methods).
+type envWithMethods struct {
+	Ctx context.Context `expr:"ctx"`
+}
+
+func (e *envWithMethods) Now2(ctx context.Context) time.Time {
+	return time.Now()
+}
+
+func (e *envWithMethods) Date2(ctx context.Context) time.Time {
+	return time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)
+}
+
+func TestIssue823_EnvMethods(t *testing.T) {
+	p, err := expr.Compile(
+		"Now2().After(Date2())",
+		expr.Env(&envWithMethods{}),
+		expr.WithContext("ctx"),
+	)
+	require.NoError(t, err)
+
+	r, err := expr.Run(p, &envWithMethods{Ctx: context.Background()})
+	require.NoError(t, err)
+	require.True(t, r.(bool))
 }
diff --git a/test/issues/924/issue_test.go b/test/issues/924/issue_test.go
@@ -0,0 +1,23 @@
+package issue_test
+
+import (
+	"testing"
+
+	"github.com/expr-lang/expr"
+	"github.com/expr-lang/expr/internal/testify/require"
+)
+
+func TestIssue924_allow_disabling_builtins_and_providing_fn_at_runtime(t *testing.T) {
+	// We disable the builtin "upper", but do not env information,
+	// but we can provide a function at runtime.
+	program, err := expr.Compile(`upper(1)`, expr.DisableBuiltin("upper"))
+	require.NoError(t, err)
+
+	env := map[string]any{
+		"upper": func(a int) int { return a },
+	}
+
+	out, err := expr.Run(program, env)
+	require.NoError(t, err)
+	require.Equal(t, 1, out)
+}
diff --git a/vm/vm_test.go b/vm/vm_test.go
@@ -1512,20 +1512,44 @@ func TestVM_StackUnderflow(t *testing.T) {
 	}
 }
 
-func TestVM_OpCall_InvalidNumberOfArguments(t *testing.T) {
-	// This test ensures that calling a function with wrong number of arguments
-	// produces a clear error message instead of a panic.
-	// Regression test for clusterfuzz issue with expression:
-	// $env(''matches'  '? :now().UTC(g).d)//
-
+func TestVM_EnvNotCallable(t *testing.T) {
+	// $env is the environment, not a function.
 	env := map[string]any{
 		"ok": true,
 	}
 
 	code := `$env('' matches ' '? : now().UTC(g))`
-	program, err := expr.Compile(code, expr.Env(env))
+	_, err := expr.Compile(code, expr.Env(env))
+	require.Error(t, err)
+	require.Contains(t, err.Error(), "is not callable")
+}
+
+func TestVM_OpCall_InvalidNumberOfArguments(t *testing.T) {
+	// Test that the VM validates argument count at runtime.
+	// Compile without Env() so compiler generates OpCall without type info.
+	program, err := expr.Compile(`fn(1, 2)`)
 	require.NoError(t, err)
 
+	// Run with a function that has different arity
+	env := map[string]any{
+		"fn": func(a int) int { return a },
+	}
+
+	_, err = expr.Run(program, env)
+	require.Error(t, err)
+	require.Contains(t, err.Error(), "invalid number of arguments")
+}
+
+func TestVM_OpCall_InvalidNumberOfArguments_Variadic(t *testing.T) {
+	// Test variadic function with too few arguments.
+	program, err := expr.Compile(`fn()`)
+	require.NoError(t, err)
+
+	// Run with a variadic function that requires at least 1 argument
+	env := map[string]any{
+		"fn": func(first int, rest ...int) int { return first },
+	}
+
 	_, err = expr.Run(program, env)
 	require.Error(t, err)
 	require.Contains(t, err.Error(), "invalid number of arguments")

Original file line number	Diff line number	Diff line change
`@@ -564,6 +564,9 @@ func flatten(arg reflect.Value, depth int) ([]any, error) {`
`564`	`564`	`}`
`565`	`565`
`566`	`566`	`func get(params ...any) (out any, err error) {`
	`567`	`+ if len(params) < 2 {`
	`568`	`+ return nil, fmt.Errorf("invalid number of arguments (expected 2, got %d)", len(params))`
	`569`	`+ }`
`567`	`570`	`from := params[0]`
`568`	`571`	`i := params[1]`
`569`	`572`	`v := reflect.ValueOf(from)`