variable `include`d from file not defined in `Main` in 1.12

[pjaap]

Hey there, I have a failing test with Julia 1.12 (beta3). Here is a MWE:

A file test.jl constains only the line a = 42.

julia> function foo()
           include("test.jl")
           return a
       end
foo (generic function with 1 method)

With julia 1.11.5:

julia> using Test; @test foo() == 42
Test Passed

With Julia 1.12 (beta3):

julia> using Test; @test foo() == 42
Error During Test at REPL[2]:1
  Test threw exception
  Expression: foo() == 42
  UndefVarError: `a` not defined in `Main`
  Suggestion: check for spelling errors or missing imports.
  Stacktrace:
   [1] foo()
     @ Main ./REPL[1]:3
   [2] top-level scope
     @ REPL[2]:1
   [3] macro expansion
     @ ~/.julia/juliaup/julia-1.12.0-beta3+0.x64.linux.gnu/share/julia/stdlib/v1.12/Test/src/Test.jl:676 [inlined]
ERROR: There was an error during testing

According to the docs, include should evaluate the contents of test.jl in the current module, which is Main. So I believe this is a regression in Julia 1.12

[nsajko]

Reproducer that doesn't depend on the test system:

julia> function foo()
           include("/tmp/j.jl")  # contents: `a = 7`
           return a
       end
foo (generic function with 1 method)
 
julia> foo()
ERROR: UndefVarError: `a` not defined in `Main`
Suggestion: check for spelling errors or missing imports.
Stacktrace:
 [1] foo()
   @ Main ./REPL[1]:3
 [2] top-level scope
   @ REPL[2]:1

[pjaap]

Thanks, I changed the title

[giordano]

Duplicate of #58286? That was slightly different, but the symptoms look similar.

[mikmoore]

A less minimal MWE that gives some insight:

julia> function foo()
           include("test.jl")
           return a
       end
foo (generic function with 1 method)

julia> a # removing this doesn't change anything
ERROR: UndefVarError: `a` not defined in `Main`
Suggestion: check for spelling errors or missing imports.

julia> foo() # the first call fails
ERROR: UndefVarError: `a` not defined in `Main`
Suggestion: check for spelling errors or missing imports.
Stacktrace:
 [1] foo()
   @ Main ./REPL[1]:3
 [2] top-level scope
   @ REPL[3]:1

julia> a # removing this doesn't change anything
42

julia> foo() # the second call succeeds
42

So it looks like a world age issue (or something of that flavor -- honestly all that stuff is above me) of some sort, where in v1.12 the global is not available until after the function has returned (and then is defined in future calls). It looks like there might be relevant discussion in the above-referenced issue, but that discussion is a little technical for me.

I'll remark that using include within a function is a footgun and is something that we might prefer to forbid (or wish we had, in an alternate timeline). I think people tend to misunderstand the implications of evaluation in global scope.

[vtjnash]

Our UndefVarError error messages are not world-aware, so they can print somewhat nonsensical results when they didn't happen in the latest world

julia> function foo()
           @eval global a = 1
           return a
       end
foo (generic function with 1 method)

julia> foo()
ERROR: UndefVarError: `a` not defined in `Main`
Suggestion: check for spelling errors or missing imports.

[vtjnash]

I think the main question is whether return a is supposed to declare the weak existence of global a (resolves-or-creates a during method definition). Of course we couldn't have done that before bindings were world-aware, but I think we could do that now without too much issue (other than conflicting with printing the backdated const warning)?

julia> GlobalRef(Main, :a).binding
Binding Main.a
   38660:∞ - undefined binding - guard entry

[Keno]

I think the main question is whether return a is supposed to declare the weak existence of global a (resolves-or-creates a during method definition).

Last time this came up, I think we reached the conclusion that only explicit global a does that, but I don't recall if there was a good reason for that.