parse context.Background() wrongly to emptyCtx instead of *emptyCtx

[StephenWuyun]

func TestRun(t *testing.T) {
	input := `ip(ctx) == "123"`
	program, err := expr.Compile(input, expr.Function("ip", ip, new(func(context.Context) string)))
	if err != nil {
		t.Fatal(err)
	}
	t.Log(expr.Run(program, map[string]interface{}{
		"ctx": context.Background(),
	}))
	t.Log(expr.Run(program, map[string]interface{}{
		"ctx": context.WithValue(context.Background(), "ip", "123"),
	}))
}

func ip(params ...any) (any, error) {
	if len(params) != 1 {
		return nil, fmt.Errorf("ip: expected 1 parameter, got %d", len(params))
	}
	fmt.Println(reflect.TypeOf(params[0]))
	ctx, ok := params[0].(context.Context)
	if !ok {
		return nil, fmt.Errorf("ip: expected context as first parameter")
	}
	_ = ctx
	//ret, ok := metadata.GetClientIpv4(ctx)
	//if !ok {
	//	return nil, fmt.Errorf("ip: failed to get ip from context")
	//}
	//
	//return ret.String(), nil
	return "123", nil
}

[antonmedv]

Please explain.

[StephenWuyun]

I added some debug code as follow:

[StephenWuyun]

*context.emptyCtx implements the interface context.Context, but the value type context.emptyCtx does not implement the interface

[StephenWuyun]

[StephenWuyun]

[antonmedv]

Please, write a minimal test case what fails.

[antonmedv]

Seems to be working fine:

func TestIssue397(t *testing.T) {
	program, err := expr.Compile(`get(ctx)`, expr.Function("get", func397, func397))
	require.NoError(t, err)

	output, err := expr.Run(program, map[string]interface{}{
		"ctx": context.WithValue(context.Background(), "value", "test"),
	})
	require.NoError(t, err)
	require.Equal(t, "test", output)
}

func func397(params ...interface{}) (interface{}, error) {
	if len(params) != 1 {
		return nil, fmt.Errorf("ip: expected 1 parameter, got %d", len(params))
	}
	ctx, ok := params[0].(context.Context)
	if !ok {
		return nil, fmt.Errorf("ip: expected context as first parameter")
	}
	return ctx.Value("value"), nil
}

[antonmedv]

I see. Now I got the problem.

Expr tries to deref everything it puts on stack:

0  OpLoadConst  <0>  ctx
1  OpDeref

[antonmedv]

And the runtime.Deref will deref it as the context.emptyCtx is an int.

[antonmedv]

Expr will dereference everything, but not reflect.Struct, reflect.Map, reflect.Array, reflect.Slice.

[antonmedv]

Without OpDeref expr will need explicit deref operators. And we cannot, for example, compare *int == int. This feature allows to implicitly deref.

Otherwise all tests will fail:

interface conversion: interface {} is *int, not int (1:3)
 | i == 1 && map.i == 1
 | ..^