expr.WithContext with nested struct member method

[echoface]

type X struct {}
func (x *X) HelloCtx(ctx context.Context, text string) error {
    fmt.Println("hello:", text)
    return nil
}

Convey("test goexr engine", t, func() {
    env := map[string]any{
        "_goctx_": context.TODO(),
        "_g_": map[string]*X{
            "rpc": &X{},
        },
        "text":    "gonghuan",
    }
    exprStr := `
        let v = _g_.rpc.HelloCtx(_goctx_, text);
   `
    program, err := expr.Compile(exprStr, expr.Env(env), expr.WithContext("_goctx_"))
    So(err, ShouldBeNil)
    _, err := expr.Run(program, env)
    So(err, ShouldBeNil)
})

it will fail call HelloCtx with

    Expected: nil
    Actual:   'reflect: Call with too few input arguments (3:20)
          |    let v = _g_.rpc.HelloCtx(text);

but if level up "rpc" to env map like this:

// this is ok
env := map[string]any{
        "_goctx_": context.TODO(),
        "_g_":  &X{},
        "text":    "gonghuan",
    }

// wrong

env := map[string]any{
        "_goctx_": context.TODO(),
        "_g_": map[string]*X{
            "rpc": &X{},
        },
        "text":    "gonghuan",
    }

is seems like a bug? help pls...

[echoface]

@antonmedv is any idea of this

[antonmedv]

Yes. Looks like a bug. WithContext patches for some reason does not see type of "map[string]*X". I will try to debug it.

For a quick fix, you can implement your own patcher for now, which will add ctx to your types.

[echoface]

it seems here need handle reflect.Interface type and unwind to underlying type

	if fn.Kind() != reflect.Func {
			return
		}

[echoface]

for this case:

"_g_": map[string]any {
      "rpc": &X{},
},

"rpc": &X{} => it be treated as 'any' type, but a struct type
maybe? the reason is that the WithContext patcher cannot recognize it as *X. It seems that reflection is needed to record each map element type during the AST parsing phase

for my case, a workaround just use named type:

"_g_": map[string]*X {
      "rpc": &X{},
},

[antonmedv]

So with map[string]*X patcher works?

[echoface]

So with map[string]*X patcher works?

yes

[antonmedv]

I just checked. Everything words. See a9cda30

[echoface]

@antonmedv thanks alots; last release tag was 2024, any plan for next release tag?

[antonmedv]

https://github.com/expr-lang/expr/releases/tag/v1.17.0

[echoface]

@antonmedv some case still not working

code main.go

// go.mod
go 1.21

require (
	code.byted.org/lang/gg v0.17.0
	github.com/expr-lang/expr v1.17.1
)

// main.go
package main

import (
	"context"
	"fmt"

	"code.byted.org/lang/gg/gvalue"
	"github.com/expr-lang/expr"
)

type X struct{}

func (x *X) HelloCtx(ctx context.Context, v any) error {
	fmt.Println("ctx is nil:", gvalue.IsNil(ctx))
	fmt.Println("hello:", v)
	return nil
}

func (x *X) Format(ctx context.Context, v1, v2, v3, v4, v5, v6, v7, v8, v9 string) error {
	fmt.Println(v1, v2, v3, v4, v5, v6, v7, v8, v9)
	return nil
}

func PanicIfErr(err error) {
	if err != nil {
		panic(err)
	}
}

var exprStr = `_g_.rpc.HelloCtx(text)`

func FailCase() {
	fmt.Println("")
	fmt.Println("run fail case >>>>>>>>>>>>>>>>>>>>>>>>>>")
	env := map[string]any{
		"_goctx_": context.TODO(),
		"text":    "fail fail fail",
		"_g_": map[string]any{
			"rpc": &X{},
		},
	}
	program, err := expr.Compile(exprStr, expr.Env(env), expr.WithContext("_goctx_"))
	PanicIfErr(err)
	res, err := expr.Run(program, env)
	PanicIfErr(err)
	fmt.Println("result:", res)
}

func SuccCase() {
	fmt.Println("")
	fmt.Println("run succ case >>>>>>>>>>>>>>>>>>>>>>>>>>")
	env := map[string]any{
		"_goctx_": context.TODO(),
		"text":    "succ succ succ",
		"_g_": map[string]*X{
			"rpc": {},
		},
	}
	program, err := expr.Compile(exprStr, expr.Env(env), expr.WithContext("_goctx_"))
	PanicIfErr(err)
	res, err := expr.Run(program, env)
	PanicIfErr(err)
	fmt.Println("result:", res)
}

func main() {
	// ok :  "_g_": map[string]*X { // it's ok
	// fail: "_g_": map[string]any{ // it give a err: 'reflect: Call with too few input arguments (3:20)

	SuccCase()

	FailCase()
}

output:

run succ case >>>>>>>>>>>>>>>>>>>>>>>>>>
ctx is nil: false
hello: succ succ succ
result: <nil>

run fail case >>>>>>>>>>>>>>>>>>>>>>>>>>
panic: reflect: Call with too few input arguments (1:9)
 | _g_.rpc.HelloCtx(text)
 | ........^

goroutine 1 [running]:
main.PanicIfErr(...)

[antonmedv]

In fail case you use:

		"_g_": map[string]any{
			"rpc": &X{},
		},

Expr sees type of g as map[string]any. So typoe of _g_.rpc.HelloCtx is any. And context patcher does not know what ctx should be added.

In latest v1.17, I've added a new cool package: https://github.com/expr-lang/expr/tree/master/types

Try to use it like this:

https://go.dev/play/p/moANOfZ9vrQ

package main

import (
	"context"
	"fmt"

	"github.com/expr-lang/expr"
	"github.com/expr-lang/expr/types"
)

type X struct{}

func (x *X) HelloCtx(ctx context.Context, v any) error {
	fmt.Printf("ctx is %T %v\n", ctx, ctx)
	fmt.Println("hello:", v)
	return nil
}

func (x *X) Format(ctx context.Context, v1, v2, v3, v4, v5, v6, v7, v8, v9 string) error {
	fmt.Println(v1, v2, v3, v4, v5, v6, v7, v8, v9)
	return nil
}

func PanicIfErr(err error) {
	if err != nil {
		panic(err)
	}
}

var exprStr = `_g_.rpc.HelloCtx(text)`

func main() {
+	envTypes := types.Map{
+		"_goctx_": types.TypeOf(context.TODO()),
+		"text":    types.String,
+		"_g_": types.Map{
+			"rpc": types.TypeOf(&X{}),
+		},
+	}
	program, err := expr.Compile(exprStr, expr.Env(envTypes), expr.WithContext("_goctx_"))
	PanicIfErr(err)

	env := map[string]any{
		"_goctx_": context.TODO(),
		"text":    "ok ok ok",
		"_g_": map[string]any{
			"rpc": &X{},
		},
	}
	res, err := expr.Run(program, env)
	PanicIfErr(err)
	fmt.Println("result:", res)
}