How can I get access to the function type in Patcher in 1.15.8 as CallNode.Func has been removed?

[tw1nk]

Context:

I have a patcher that modifies the CallNode function arguments as I don't want our users to have to add Ctx for functions that require a context.Context

in 1.15.7 this works

type ContextPatcher struct{}

func (p *ContextPatcher) Visit(node *ast.Node) {
	// we need to set the node type to nil to make sure we're not getting
	// caught by invalid types
	// https://github.com/expr-lang/expr/discussions/473#discussioncomment-7666118
	(*node).SetType(nil)

	contextType := reflect.TypeOf((*context.Context)(nil)).Elem()

	if callNode, ok := (*node).(*ast.CallNode); ok {
		if callNode.Func != nil {
			// patch context calls so we don't have to pass the context in the code
			funcType := callNode.Func.Types[0]
			if funcType.NumIn() > 0 {
				firstIn := funcType.In(0)

				if firstIn.Implements(contextType) {
					// prepend patch context calls so we don't need to specify the context
					args := append([]ast.Node{
						&ast.IdentifierNode{
							Value: "ctx",
						},
					}, callNode.Arguments...)

					ast.Patch(node, &ast.CallNode{
						Callee:    callNode.Callee,
						Arguments: args,
						Typed:     callNode.Typed,
						Fast:      callNode.Fast,
						Func:      callNode.Func,
					})
				}
			}
		}
	}
}

When looking at the PR #504 (https://github.com/expr-lang/expr/pull/504/files) which removed the Func field from CallNode I can't find out how I can get access to the function information anymore?

[antonmedv]

Yes, this is still possible to do. Your current implementation has a few errors and I removed Func specifically to emphasize a correct solution: use call.Callee.Type() to get a func type.

switch (*node).(type) {
	case *ast.CallNode:
		call := (*node).(*ast.CallNode)
		fn := call.Callee.Type()
		if fn.Kind() != reflect.Func {
			return
		}
		if fn.NumIn() == 0 {
			return
		}
		if fn.In(0).String() != "context.Context" {
			return
		}
		ast.Patch(node, &ast.CallNode{
			Callee: call.Callee,
			Arguments: append([]ast.Node{
				&ast.IdentifierNode{Value: "ctx"},
			}, call.Arguments...),
		})
	}

Or you can also use a patcher that comes with Expr itself https://pkg.go.dev/github.com/expr-lang/expr#WithContext

	program, err := expr.Compile(`fn(1, 2)`,
		expr.Env(env),
		expr.WithContext("ctx"), // Pass context variable name.
	)

[antonmedv]

Created #524

[antonmedv]

Here is a fix #526

[tw1nk]

#526 almost works

with this test

type TestFoo struct {
	contextValue int
}

func (f *TestFoo) GetValue(a int) int64 {
	return int64(f.contextValue + a)
}

func TestWithContext_with_env_method_chain(t *testing.T) {
	env := map[string]any{
		"ctx": context.TODO(),
	}

	fn := expr.Function("fn",
		func(params ...any) (any, error) {
			ctx := params[0].(context.Context)

			contextValue := ctx.Value("value").(int)

			return &TestFoo{
				contextValue: contextValue,
			}, nil
		},
		new(func(context.Context) *TestFoo),
	)

	program, err := expr.Compile(
		`fn().GetValue(40)`,
		expr.Env(env),
		expr.WithContext("ctx"),
		fn,
		expr.AsInt64(),
	)
	require.NoError(t, err)

	ctx := context.WithValue(context.Background(), "value", 2)
	env["ctx"] = ctx

	output, err := expr.Run(program, env)
	require.NoError(t, err)
	require.Equal(t, 42, output)
}

it seems the return value is lost as expr.Compile returns this error:

expected int64, but got interface {}

[antonmedv]

This was a very interesting bug. Fix was small, but to understand why was difficult. But I fixed it and added your test case: 98d79a9

[tw1nk]

Thanks that solves all issues for me, Waiting for a new official version to be released.