Still problems assigning to variables in other packages from `main`, whether in "binary" or fully-interpreted code

[theclapp]

The following test case in interp/interp_eval_test.go triggers an unexpected result

func TestIssue1632(t *testing.T) {
    var j int

    i := interp.New(interp.Options{})
    if err := i.Use(interp.Exports{
        "pkg/pkg": map[string]reflect.Value{
            "J": reflect.ValueOf(&j).Elem(),
        },
    }); err != nil {
        t.Fatal(err)
    }
    i.ImportUsed()

    _, err := i.Eval(`func f(i int) int { return i }`)
    if err != nil {
        t.Fatal(err)
    }
    testJ := func(initJ int, src, expected string) {
        t.Helper()
        t.Run(src, func(t *testing.T) {
            t.Helper()
            j = initJ
            assertEval(t, i, src, "", expected)
        })
    }

    // These all work.
    testJ(0, "pkg.J = 1; pkg.J", "1")
    testJ(0, "pkg.J = pkg.J + 1; pkg.J", "1")
    testJ(0, "f(1)", "1")
    testJ(1, "f(pkg.J)", "1")
    testJ(0, "pkg.J += 1; pkg.J", "1")
    testJ(0, "pkg.J += 1; f(*&pkg.J)", "1")
    testJ(0, "pkg.J++; f(*&pkg.J)", "1")
    testJ(0, "*&pkg.J = f(1); pkg.J", "1")
    testJ(0, "k := 1; pkg.J = k; pkg.J", "1")
    testJ(0, "k := 1; *&pkg.J = f(k); pkg.J", "1")
    testJ(0, "pkg.J += 1; f(*&pkg.J+1)", "2")

    // These all fail
    testJ(0, "pkg.J += 1; f(pkg.J)", "1")            // get 0
    testJ(0, "pkg.J += 1; f(pkg.J+1)", "2")          // get 1
    testJ(0, "pkg.J++; f(pkg.J)", "1")               // get 0
    testJ(0, "pkg.J = pkg.J + 1; f(pkg.J)", "1")     // get 0
    testJ(1, "pkg.J = pkg.J + pkg.J; f(pkg.J)", "2") // get 1
    testJ(2, "pkg.J = f(1); pkg.J", "1")             // get 2 (this one's especially surprising)
    testJ(0, "k := 1; pkg.J = f(k); pkg.J", "1")     // get 0
    testJ(0, "pkg.J = 1; k := pkg.J; k", "1")        // get 0

    // Try these tests with strictly interpreted code
    i = interp.New(interp.Options{})
    _, err = i.Eval(`package pkg; var J int`)
    if err != nil {
        t.Fatal(err)
    }
    _, err = i.Eval(`package main
import "pkg"
func f(i int) int { return i }`)
    if err != nil {
        t.Fatal(err)
    }

    testJ = func(initJ int, src, expected string) {
        t.Helper()
        t.Run(src, func(t *testing.T) {
            t.Helper()

            res, err := i.Eval(fmt.Sprintf("pkg.J = %d; pkg.J", initJ))
            if err != nil {
                t.Fatal(err)
            }
            if res.Interface().(int) != initJ {
                t.Fatalf("Expected pkg.J to be %d, got %v", initJ, res)
            }
            assertEval(t, i, src, "", expected)
        })
    }

    // These all still succeed
    testJ(0, "pkg.J = 1; pkg.J", "1")
    testJ(0, "f(1)", "1")
    testJ(1, "f(pkg.J)", "1")
    testJ(0, "pkg.J += 1; pkg.J", "1")
    testJ(0, "pkg.J += 1; f(*&pkg.J)", "1")
    testJ(0, "pkg.J++; f(*&pkg.J)", "1")
    testJ(0, "*&pkg.J = f(1); pkg.J", "1")
    testJ(0, "k := 1; pkg.J = k; pkg.J", "1")
    testJ(0, "k := 1; *&pkg.J = f(k); pkg.J", "1")
    testJ(0, "pkg.J += 1; f(*&pkg.J+1)", "2")

    // These all succeed but don't above
    testJ(0, "pkg.J += 1; f(pkg.J)", "1")
    testJ(0, "pkg.J += 1; f(pkg.J+1)", "2")
    testJ(0, "pkg.J++; f(pkg.J)", "1")
    testJ(0, "pkg.J = 1; k := pkg.J; k", "1")

    // This fails but didn't used to
    testJ(0, "pkg.J = pkg.J + 1; pkg.J", "1") // get 0

    // These all still fail
    testJ(0, "pkg.J = pkg.J + 1; f(pkg.J)", "1")     // get 0
    testJ(1, "pkg.J = pkg.J + pkg.J; f(pkg.J)", "2") // get 1
    testJ(2, "pkg.J = f(1); pkg.J", "1")             // get 2
    testJ(0, "k := 1; pkg.J = f(k); pkg.J", "1")     // get 0
}

Expected result

All tests pass

Got

--- FAIL: TestIssue1632 (0.00s)
    --- FAIL: TestIssue1632/pkg.J_+=_1;_f(pkg.J) (0.00s)
        interp_eval_test.go:1974: got 0, want 1
    --- FAIL: TestIssue1632/pkg.J_+=_1;_f(pkg.J+1) (0.00s)
        interp_eval_test.go:1975: got 1, want 2
    --- FAIL: TestIssue1632/pkg.J++;_f(pkg.J) (0.00s)
        interp_eval_test.go:1976: got 0, want 1
    --- FAIL: TestIssue1632/pkg.J_=_pkg.J_+_1;_f(pkg.J) (0.00s)
        interp_eval_test.go:1977: got 0, want 1
    --- FAIL: TestIssue1632/pkg.J_=_pkg.J_+_pkg.J;_f(pkg.J) (0.00s)
        interp_eval_test.go:1978: got 1, want 2
    --- FAIL: TestIssue1632/pkg.J_=_f(1);_pkg.J (0.00s)
        interp_eval_test.go:1979: got 2, want 1
    --- FAIL: TestIssue1632/k_:=_1;_pkg.J_=_f(k);_pkg.J (0.00s)
        interp_eval_test.go:1980: got 0, want 1
    --- FAIL: TestIssue1632/pkg.J_=_1;_k_:=_pkg.J;_k (0.00s)
        interp_eval_test.go:1981: got 0, want 1
    --- FAIL: TestIssue1632/pkg.J_=_pkg.J_+_1;_pkg.J#01 (0.00s)
        interp_eval_test.go:2031: got 0, want 1
    --- FAIL: TestIssue1632/pkg.J_=_pkg.J_+_1;_f(pkg.J)#01 (0.00s)
        interp_eval_test.go:2034: got 0, want 1
    --- FAIL: TestIssue1632/pkg.J_=_pkg.J_+_pkg.J;_f(pkg.J)#01 (0.00s)
        interp_eval_test.go:2035: got 1, want 2
    --- FAIL: TestIssue1632/pkg.J_=_f(1);_pkg.J#01 (0.00s)
        interp_eval_test.go:2036: got 2, want 1
    --- FAIL: TestIssue1632/k_:=_1;_pkg.J_=_f(k);_pkg.J#01 (0.00s)
        interp_eval_test.go:2037: got 0, want 1
FAIL
FAIL    github.com/traefik/yaegi/interp 0.357s
FAIL

Yaegi Version

381e045

Additional Notes

Related: #1623 .

Obviously I changed assertEval to use Errorf instead of Fatalf.

[theclapp]

Sometimes the problem is in assigning to pkg.J, sometimes it's with passing pkg.J to a function. It's like Yaegi decides (in the cfg code, maybe?) that pkg.J is a constant, evaluates it once at compile-time, and doesn't later re-evaluate it when it should (at run-time). The use of *&pkg.J gets around that.