Merge pull request #65 from disberd/fix_v12

Author: disberd

.github/workflows/CI.yml

@@ -18,32 +18,29 @@ concurrency:
   cancel-in-progress: ${{ startsWith(github.ref, 'refs/pull/') }}
 jobs:
   test:
-    name: Julia ${{ matrix.version }} - ${{ matrix.os }} - ${{ matrix.arch }} - ${{ github.event_name }}
+    name: Julia ${{ matrix.version }} - ${{ matrix.os }} - ${{ github.event_name }}
     runs-on: ${{ matrix.os }}
     strategy:
       fail-fast: false
       matrix:
         version:
           - '1'
-          - '1.9'
+          - 'lts'
           - 'pre'
         os:
           - ubuntu-latest
           - macOS-latest
           - windows-latest
-        arch:
-          - x64
     steps:
       - uses: actions/checkout@v4
       - uses: julia-actions/setup-julia@v2
         with:
           version: ${{ matrix.version }}
-          arch: ${{ matrix.arch }}
-      - uses: julia-actions/cache@v1
+      - uses: julia-actions/cache@v2
       - uses: julia-actions/julia-buildpkg@v1
       - uses: julia-actions/julia-runtest@v1
       - uses: julia-actions/julia-processcoverage@v1
-      - uses: codecov/codecov-action@v4
+      - uses: codecov/codecov-action@v5
         with:
-          files: lcov.info
-          token: ${{ secrets.CODECOV_TOKEN }}
+          token: ${{ secrets.CODECOV_TOKEN }}
+          slug: disberd/PlutoDevMacros.jl

.gitignore

@@ -5,4 +5,7 @@ docs/build/
 
 pluto_test*.jl
 test*.jl
-!test/**/*.jl
+!test/**/*.jl
+
+# Coverage
+coverage/

Project.toml

@@ -11,9 +11,9 @@ Pkg = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f"
 TOML = "fa267f1f-6049-4f14-aa54-33bafae1ed76"
 
 [compat]
-JuliaInterpreter = "0.9"
+JuliaInterpreter = "0.9, 0.10"
 Logging = "1"
 MacroTools = "0.5"
 Pkg = "1"
 TOML = "1"
-julia = "1.9"
+julia = "1.10"

src/frompackage/consts.jl

@@ -1,9 +1,11 @@
 const IS_DEV = first(fullname(@__MODULE__)) === :Main
-const TEMP_MODULE_NAME = Symbol(:_FrompPackage_TempModule_, IS_DEV ? "DEV_" : "")
+const TEMP_MODULE_NAME = Symbol(:_FromPackage_TempModule_, IS_DEV ? "DEV_" : "")
 const STDLIBS_DATA = Dict{String,Base.UUID}()
 for (uuid, (name, _)) in Pkg.Types.stdlibs()
     STDLIBS_DATA[name] = uuid
 end
 const PREV_CONTROLLER_NAME = Symbol(:_Previous_Controller_, IS_DEV ? "DEV_" : "")
 
-const CURRENT_FROMPACKAGE_CONTROLLER = Ref{FromPackageController}()
+const CURRENT_FROMPACKAGE_CONTROLLER = Ref{FromPackageController}()
+
+const LOADED_TIMES = Dict{Symbol, Int}()

src/frompackage/helpers.jl

@@ -53,7 +53,7 @@ end
 
 function _popup_style()
 #! format: off
-"""
+return """
 fromparent-container {
   height: 20px;
   position: fixed;
@@ -171,9 +171,19 @@ function extract_target_path(ex, caller_module::Module; calling_file, notebook_l
     return path
 end
 
+# Mostly like fullname, but for modules we generated we always have the path from Main
+function _fullname(m::Module)
+    ref = fullname(m) |> collect
+    rootname = first(ref)
+    rootname === :Main && return ref # This is already fine
+    temp_mod = get_temp_module()
+    return invokelatest(isdefined, temp_mod, rootname) ? prepend!(ref, fullname(temp_mod)) : ref
+end
+
 function beautify_package_path(p::FromPackageController)
     @nospecialize
     modpath..., name = fullname(get_temp_module(p))
+    isempty(modpath) && return "" # If the module was loaded as roootmodule, on 1.12 it also becomes it's own parent so we don't have modpath
     modpath = map(enumerate(modpath)) do (i, s)
         Base.isgensym(s) || return String(s)
         return "var\"$s\""
@@ -267,7 +277,7 @@ end
 
 function populate_manifest_deps!(p::FromPackageController)
     @nospecialize
-    (;manifest_deps) = p
+    (; manifest_deps) = p
     d = TOML.parsefile(get_manifest_file(p))
     for (name, data) in d["deps"]
         # We use `only` here because I believe the entry will always contain a single dict wrapped in an array. If we encounter a case where this is not true the only will throw instead of silently taking just the first
@@ -285,13 +295,15 @@ function get_manifest_file(p::FromPackageController)
     proj_file = project.file
     envdir = dirname(abspath(proj_file))
     manifest_file = if mode in (:instantiate, :resolve)
-        context_kwargs = options.verbose ? (;) : (; io = devnull)
-        c = Context(;env = EnvCache(proj_file), context_kwargs...)
+        context_kwargs = options.verbose ? (;) : (; io=devnull)
+        c = Context(; env=EnvCache(proj_file), context_kwargs...)
         resolve = mode === :resolve
         if resolve
+            options.verbose && @info "Resolving Manifest as explicitly requested"
             Pkg.resolve(c)
         else
-            Pkg.instantiate(c; update_registry = false, allow_build = false, allow_autoprecomp = false)
+            options.verbose && @info "Instantiating Manifest as explicitly requested"
+            Pkg.instantiate(c; update_registry=false, allow_build=false, allow_autoprecomp=false)
         end
         joinpath(envdir, "Manifest.toml")
     else
@@ -338,8 +350,8 @@ function extract_nested_module(starting_module::Module, nested_path; first_dot_s
         m = if name === :.
             first_dot_skipped ? parentmodule(m) : m
         else
-            @assert isdefined(m, name) "The module `$name` could not be found inside parent module `$(nameof(m))`"
-            getproperty(m, name)::Module
+            @assert invokelatest(isdefined, m, name) "The module `$name` could not be found inside parent module `$(nameof(m))`"
+            invokelatest(getproperty, m, name)::Module
         end
         first_dot_skipped = true
     end
@@ -351,20 +363,24 @@ unique_module_name(m::Module) = Symbol(Base.PkgId(m))
 unique_module_name(uuid::Base.UUID, name::AbstractString) = Symbol(Base.PkgId(uuid, name))
 
 function get_temp_module()
-    if isdefined(Main, TEMP_MODULE_NAME)
-        getproperty(Main, TEMP_MODULE_NAME)::Module
-    else
-        Core.eval(Main, :(module $TEMP_MODULE_NAME
-        module _LoadedModules_ end
-        module _DirectDeps_ end
-        end))::Module
+    invokelatest() do
+        if isdefined(Main, TEMP_MODULE_NAME)
+            getproperty(Main, TEMP_MODULE_NAME)::Module
+        else
+            Core.eval(Main, :(module $TEMP_MODULE_NAME
+            module _LoadedModules_ end
+            module _DirectDeps_ end
+            end))::Module
+        end
     end
 end
 get_temp_module(s::Symbol) = get_temp_module([s])
 function get_temp_module(names::Vector{Symbol})
-    temp = get_temp_module()
-    out = extract_nested_module(temp, names)::Module
-    return out
+    invokelatest(names) do names
+        temp = get_temp_module()
+        out = extract_nested_module(temp, names)::Module
+        return out
+    end
 end
 function get_temp_module(::FromPackageController{name}) where {name}
     @nospecialize
@@ -374,38 +390,44 @@ end
 get_loaded_modules_mod() = get_temp_module(:_LoadedModules_)::Module
 get_direct_deps_mod() = get_temp_module(:_DirectDeps_)::Module
 
-function populate_loaded_modules(; verbose=false)
-    loaded_modules = get_loaded_modules_mod()
-    @lock Base.require_lock begin
-        for (id, m) in Base.loaded_modules
-            name = Symbol(id)
-            isdefined(loaded_modules, name) && continue
-            Core.eval(loaded_modules, :(const $name = $m))
+function populate_loaded_modules(p::Union{FromPackageController, Nothing} = nothing; verbose=false)
+    invokelatest() do
+        loaded_modules = get_loaded_modules_mod()
+        @lock Base.require_lock begin
+            for (id, m) in Base.loaded_modules
+                # We check and eventually skip the target package from the loaded modules
+                if p isa FromPackageController
+                    p.project.name == id.name && p.project.uuid == id.uuid && continue
+                end
+                name = Symbol(id)
+                isdefined(loaded_modules, name) && continue
+                Core.eval(loaded_modules, :(const $name = $m))
+            end
         end
-    end
-    callbacks = Base.package_callbacks
-    if mirror_package_callback ∉ callbacks
-        for i in reverse(eachindex(callbacks))
-            # This part is only useful when developing this package itself
-            f = callbacks[i]
-            nameof(f) === :mirror_package_callback || continue
-            owner = parentmodule(f)
-            nameof(owner) === nameof(@__MODULE__) || continue
-            isdefined(owner, :IS_DEV) && owner.IS_DEV || continue
-            # We delete this as it's a previous version of the mirror_package_callback function
-            verbose && @warn "Deleting previous version of package_callback function"
-            deleteat!(callbacks, i)
+        callbacks = Base.package_callbacks
+        if mirror_package_callback ∉ callbacks
+            for i in reverse(eachindex(callbacks))
+                # This part is only useful when developing this package itself
+                f = callbacks[i]
+                nameof(f) === :mirror_package_callback || continue
+                owner = parentmodule(f)
+                nameof(owner) === nameof(@__MODULE__) || continue
+                isdefined(owner, :IS_DEV) && owner.IS_DEV || continue
+                # We delete this as it's a previous version of the mirror_package_callback function
+                verbose && @warn "Deleting previous version of package_callback function"
+                deleteat!(callbacks, i)
+            end
+            # Add the package callback if not already present
+            push!(callbacks, mirror_package_callback)
         end
-        # Add the package callback if not already present
-        push!(callbacks, mirror_package_callback)
     end
 end
 
 # This function will extract a module from the _LoadedModules_ module which will be populated when each package is loaded in julia
 function get_dep_from_loaded_modules(key::Symbol)
     loaded_modules = get_loaded_modules_mod()
     isdefined(loaded_modules, key) || error("The module $key can not be found in the loaded modules.")
-    m = getproperty(loaded_modules, key)::Module
+    m = invokelatest(getproperty, loaded_modules, key)::Module
     return m
 end
 # This is internally calls the previous function, allowing to control which packages can be loaded (by default only direct dependencies and stdlibs are allowed)
@@ -443,10 +465,10 @@ end
 
 # Basically Base.names but ignores names that are not defined in the module and allows to restrict to only exported names (since 1.11 added also public names as out of names). It also defaults `all` and `imported` to true (to be more precise, to the opposite of `only_exported`)
 function _names(m::Module; only_exported=false, all=!only_exported, imported=!only_exported, kwargs...)
-    mod_names = names(m; all, imported, kwargs...)
+    mod_names = invokelatest(names, m; all, imported, kwargs...)
     filter!(mod_names) do nm
-        isdefined(m, nm) || return false
-        only_exported && return Base.isexported(m, nm)
+        invokelatest(isdefined, m, nm) || return false
+        only_exported && return invokelatest(Base.isexported, m, nm)
         return true
     end
 end

src/frompackage/imports_helpers.jl

@@ -111,10 +111,10 @@ function process_modpath!(mwn::ModuleWithNames, p::FromPackageController{name};
     if root_name in (:ParentModule, :<)
         @assert !isnothing(p.target_module) "You can't import from the Parent Module when the calling file is not a file `included` in the target package."
         m = p.target_module
-        prepend!(path, fullname(m))
+        prepend!(path, _fullname(m))
     elseif root_name in (:PackageModule, :^, name)
         m = get_temp_module(p)
-        prepend!(path, fullname(m))
+        prepend!(path, _fullname(m))
     elseif root_name === :>
         # Deps import
         @assert !is_catchall(mwn) "You can't use the catch-all expression when importing from dependencies"
@@ -128,13 +128,13 @@ function process_modpath!(mwn::ModuleWithNames, p::FromPackageController{name};
         imported = mwn.imported
         @assert isempty(imported) "You can't use the catchall import statement `import *` with explicitly imported names"
         m = @something p.target_module get_temp_module(p)
-        prepend!(path, fullname(m))
+        prepend!(path, _fullname(m))
         push!(mwn.imported, ImportAs(:*))
     elseif root_name === :.
         @assert inner || !isnothing(p.target_module) "You can't use relative imports when the calling file is not a file `included` in the target package."
         starting_module = @something p.target_module get_temp_module(p)
         m = extract_nested_module(starting_module, path; first_dot_skipped=true)
-        modname.original = fullname(m) |> collect
+        modname.original = _fullname(m) |> collect
     else
         error("The provided import statement is not a valid input for the @frompackage macro.\nIf you want to import from a dependency of the target package, prepend `>.` in front of the package name, e.g. `using >.BenchmarkTools`.")
     end
@@ -156,7 +156,7 @@ end
 # This function will include all the names of the module as explicit imports in the import statement. It will modify the provided mwn in place and unless usings are excluded, it will also add all the using statements being parsed while evaluating the target module
 function catchall_import_expression!(mwn::ModuleWithNames, p::FromPackageController, m::Module; exclude_usings::Bool)
     @nospecialize
-    mwn.imported = filterednames(p, m) .|> ImportAs
+    mwn.imported = invokelatest(filterednames, p, m) .|> ImportAs
     ex = reconstruct_import_statement(mwn; head=:import)
     # If we exclude using, we simply return the expression
     exclude_usings && return ex
@@ -188,7 +188,8 @@ function complete_imported_names!(mwn::ModuleWithNames, p::FromPackageController
         # Here we do not modify the list of explicitily imported names, as it's better to get an error if you explicitly import something that was already defined in the notebook
         return reconstruct_import_statement(mwn; head=:import)
     end
-    m = extract_nested_module(Main, mwn.modname.original)
+    nested_path = mwn.modname.original
+    m = extract_nested_module(Main, nested_path)
     if catchall
         # We extract all the names, potentially include usings encountered
         return catchall_import_expression!(mwn, p, m; exclude_usings)

src/frompackage/input_parsing.jl

@@ -36,9 +36,14 @@ end
 
 # This function will parse the input expression and eventually
 function process_input_expr(p::FromPackageController, ex)
-    # Eventually remove `@exclude_using`
-    exclude_usings = should_exclude_using_names!(ex)
-    return process_import_statement(p, ex; exclude_usings, inner=false)
+    try
+        # Eventually remove `@exclude_using`
+        exclude_usings = should_exclude_using_names!(ex)
+        return process_import_statement(p, ex; exclude_usings, inner=false)
+    catch
+        @error "Error processing input expression" ex
+        rethrow()
+    end
 end
 
 function excluded_names(p::FromPackageController)

src/frompackage/loading.jl

@@ -1,12 +1,14 @@
 function maybe_call_init(m::Module)
-    # Check if it exists
-    isdefined(m, :__init__) || return nothing
-    # Check if it's owned by this module
-    which(m, :__init__) === m || return nothing
-    f = getproperty(m, :__init__)
-    # Verify that is a function
-    f isa Function || return nothing
-    Core.eval(m, :(__init__()))
+    invokelatest() do 
+        # Check if it exists
+        isdefined(m, :__init__) || return nothing
+        # Check if it's owned by this module
+        which(m, :__init__) === m || return nothing
+        f = getproperty(m, :__init__)
+        # Verify that is a function
+        f isa Function || return nothing
+        Core.eval(m, :(__init__()))
+    end
     return nothing
 end
 
@@ -47,7 +49,7 @@ end
 
 ## Misc ##
 # Returns the name (as Symbol) of the variable where the controller will be stored within the generated module
-variable_name(p::FromPackageController) = (@nospecialize; :_frompackage_controller_)
+variable_name(p::FromPackageController) = (@nospecialize; return :_frompackage_controller_)
 
 # This is a callback to add any new loaded package to the Main._FromPackage_TempModule_._LoadedModules_ module
 function mirror_package_callback(modkey::Base.PkgId)
@@ -81,8 +83,10 @@ function try_load_extensions!(p::FromPackageController)
             options.verbose && @info "Loading code of extension $name for package $package_name"
             entry_path = find_ext_path(p.project, name)
             # Set the module to the package module parent, which is a temp module in the Pluto workspace
-            p.current_module = get_temp_module(p) |> parentmodule
+            p.current_module = get_temp_module()
             try
+                # We have to recreate the module of the extension, as ExprSplitter will not recreate it if it's already there and it will still have inside a reference to an old version of the package of interest. Not sure if this was a non-found bug before or it's only a problem with either julia 1.12 or JuliaIntepreterv0.10
+                Core.eval(p.current_module, :(module $(name |> Symbol) end))
                 # Load the extension module inside the package module
                 process_include_expr!(p, entry_path)
                 push!(p.loaded_extensions, name)
@@ -130,9 +134,12 @@ function load_module!(p::FromPackageController{name}; reset=true) where {name}
     maybe_call_init(get_temp_module(p))
     # We populate the loaded modules
     (; verbose) = p.options
-    populate_loaded_modules(;verbose)
+    populate_loaded_modules(p ;verbose)
     # Try loading extensions
     try_load_extensions!(p)
+    # We increment the number of loads
+    LOADED_TIMES[name] = get!(LOADED_TIMES, name, 0) + 1
+    p.nloads = LOADED_TIMES[name]
     return p
 end
 
@@ -183,6 +190,7 @@ function register_target_as_root(p::FromPackageController)
     @lock Base.require_lock begin
         # Set the uuid of this module with the C API. This is required to get the correct UUID just from the module within `register_root_module`
         ccall(:jl_set_module_uuid, Cvoid, (Any, NTuple{2, UInt64}), m, uuid)
+        VERSION > v"1.11.99" && ccall(:jl_set_module_parent, Cvoid, (Any, Any), m, m) # We need to also set the module as parent of itself in 1.12
         # Register this module as root
         logger = verbose ? Logging.current_logger() : Logging.NullLogger()
         Logging.with_logger(logger) do