eval in __init__ causes incorrect precompilation warning

[fredrikekre]

Noticed in a couple of packages since precompile is on by default. Setup:

using Pkg
A = joinpath(pwd(), "PackageA");
B = joinpath(pwd(), "PackageB");
Pkg.generate.(["PackageA", "PackageB"]);
Pkg.activate(A);
Pkg.develop(PackageSpec(path = B));
Pkg.activate();
Pkg.develop([PackageSpec(path = A), PackageSpec(path = B)]);
write(joinpath(A, "src", "PackageA.jl"), "module PackageA\nusing PackageB\nend");
write(joinpath(B, "src", "PackageB.jl"), "module PackageB\n__init__() = eval(:(b() = 1))\nend");

and then

julia> using PackageA
[ Info: Precompiling PackageA [578a9956-b149-11e8-3635-0b7267ab0bb3]
WARNING: eval from module PackageB to PackageA:    
Expr(:call, :b) = Expr(:block, #= Symbol("/home/fredrik/PackageB/src/PackageB.jl"):2 =#, 1)
  ** incremental compilation may be broken for this module **

See e.g. JuliaDocs/Documenter.jl#806

[JeffBezanson]

I don't think it's actually evaluating in the wrong module; I suspect the error message is inaccurate. Could you confirm whether b() ends up defined in PackageA or PackageB?

[fredrikekre]

It ends up in the correct module (PackageB)

[StefanKarpinski]

IIRC, this error message has the modules swapped for some reason? @vtjnash, I think you mentioned that to me once but maybe I was misunderstanding.

[JeffBezanson]

"eval from B to A" is supposed to mean that module B did an eval(A, ...), i.e. B "sent" some code to A. It makes sense to me but I can see how it may not be totally clear.

[vtjnash]

is supposed to mean

Yes, that's what the code looks like (some module A wants to inject an eval result into the file for B, but that will fail and emit a bad .ji cache for A), so that's probably why I ended up wording it this way. But even so, the wording does "feel" backwards to me.

[ma-laforge]

I have noticed something odd with the behaviour of __init__() that might be related:

Test Case

(Using Julia 1.0 on Ubuntu 18.04)
Assuming we have 3 packages that can be located in the Julia LOAD_PATH:

./PackageA/src/PackageA.jl:

module PackageA
function __init__()
	println("Initializing PackageA...")
end
end

./PackageA/src/PackageB.jl:

module PackageB
using PackageA
function __init__()
	println("Initializing PackageB...")
end
end

./PackageA/src/PackageC.jl:

module PackageC
using PackageB
function __init__()
	println("Initializing PackageC...")
end
end

Problem

We get a recursive behaviour with the calls to __init__() when we include PackageC. I don't think this is desired:

julia> using PackageC
[ Info: Recompiling stale cache file /home/laforge/.julia/compiled/v1.0/PackageC.ji for PackageC [top-level]
Initializing PackageA...
Initializing PackageA...
Initializing PackageB...
Initializing PackageA...
Initializing PackageB...
Initializing PackageC...

...I believe this might be causing me issues when I try to "import" my modules... I have found my software to hang unless I add show() commands in the __init__() functions of my modules (if they exist).

Secondary Observation

I also find it a bit strange that there is no message indicating that the submodules (PackageA & PackageB) were being re-compiled...

[yuyichao]

Those are not problems and are unrelated.