Backports for 1.12

src/API.jl

@@ -244,6 +244,7 @@ function develop(ctx::Context, pkgs::Vector{PackageSpec}; shared::Bool=true,
 
     new_git = handle_repos_develop!(ctx, pkgs, shared)
 
+    Operations.update_registries(ctx; force = false, update_cooldown = Day(1))
 
     for pkg in pkgs
         if Types.collides_with_project(ctx.env, pkg)
@@ -1053,18 +1054,33 @@ function gc(ctx::Context=Context(); collect_delay::Period=Day(7), verbose=false,
         end
     end
 
-    # Delete any files that could not be rm-ed and were specially moved to the delayed delete directory.
-    # Do this silently because it's out of scope for Pkg.gc() but it's helpful to use this opportunity to do it
-    if isdefined(Base.Filesystem, :delayed_delete_dir)
-        if isdir(Base.Filesystem.delayed_delete_dir())
-            for p in readdir(Base.Filesystem.delayed_delete_dir(), join=true)
+    # Delete anything that could not be rm-ed and was specially recorded in the delayed delete reference folder.
+    # Do this silently because it's out of scope for Pkg.gc() but it's helpful to use this opportunity to do it.
+    if isdefined(Base.Filesystem, :delayed_delete_ref)
+        delayed_delete_ref_path = Base.Filesystem.delayed_delete_ref()
+        if isdir(delayed_delete_ref_path)
+            delayed_delete_dirs = Set{String}()
+            for f in readdir(delayed_delete_ref_path; join = true)
                 try
+                    p = readline(f)
+                    push!(delayed_delete_dirs, dirname(p))
                     Base.Filesystem.prepare_for_deletion(p)
-                    Base.rm(p; recursive=true, force=true, allow_delayed_delete=false)
+                    Base.rm(p; recursive = true, force = true, allow_delayed_delete = false)
+                    Base.rm(f)
                 catch e
                     @debug "Failed to delete $p" exception=e
                 end
             end
+            for dir in delayed_delete_dirs
+                if basename(dir) == "julia_delayed_deletes" && isempty(readdir(dir))
+                    Base.Filesystem.prepare_for_deletion(dir)
+                    Base.rm(dir; recursive = true)
+                end
+            end
+            if isempty(readdir(delayed_delete_ref_path))
+                Base.Filesystem.prepare_for_deletion(delayed_delete_ref_path)
+                Base.rm(delayed_delete_ref_path; recursive = true)
+            end
         end
     end
 

src/Operations.jl

@@ -319,14 +319,14 @@ function reset_all_compat!(proj::Project)
     return nothing
 end
 
-function collect_project(pkg::Union{PackageSpec, Nothing}, path::String)
+function collect_project(pkg::Union{PackageSpec, Nothing}, path::String, julia_version)
     deps = PackageSpec[]
     weakdeps = Set{UUID}()
     project_file = projectfile_path(path; strict=true)
     project = project_file === nothing ?  Project() : read_project(project_file)
     julia_compat = get_compat(project, "julia")
-    if !isnothing(julia_compat) && !(VERSION in julia_compat)
-        pkgerror("julia version requirement from Project.toml's compat section not satisfied for package at `$path`")
+    if !isnothing(julia_compat) && !isnothing(julia_version) && !(julia_version in julia_compat)
+        pkgerror("julia version requirement for package at `$path` not satisfied: compat entry \"julia = $(get_compat_str(project, "julia"))\" does not include Julia version $julia_version")
     end
     for (name, uuid) in project.deps
         path, repo = get_path_repo(project, name)
@@ -385,20 +385,20 @@ function collect_developed(env::EnvCache, pkgs::Vector{PackageSpec})
     return developed
 end
 
-function collect_fixed!(env::EnvCache, pkgs::Vector{PackageSpec}, names::Dict{UUID, String})
+function collect_fixed!(env::EnvCache, pkgs::Vector{PackageSpec}, names::Dict{UUID, String}, julia_version)
     deps_map = Dict{UUID,Vector{PackageSpec}}()
     weak_map = Dict{UUID,Set{UUID}}()
 
     uuid = Types.project_uuid(env)
-    deps, weakdeps = collect_project(env.pkg, dirname(env.project_file))
+    deps, weakdeps = collect_project(env.pkg, dirname(env.project_file), julia_version)
     deps_map[uuid] = deps
     weak_map[uuid] = weakdeps
     names[uuid] = env.pkg === nothing ? "project" : env.pkg.name
 
     for (path, project) in env.workspace
         uuid = Types.project_uuid(project, path)
         pkg = project.name === nothing ? nothing : PackageSpec(name=project.name, uuid=uuid)
-        deps, weakdeps = collect_project(pkg, path)
+        deps, weakdeps = collect_project(pkg, path, julia_version)
         deps_map[Types.project_uuid(env)] = deps
         weak_map[Types.project_uuid(env)] = weakdeps
         names[uuid] = project.name === nothing ? "project" : project.name
@@ -418,7 +418,7 @@ function collect_fixed!(env::EnvCache, pkgs::Vector{PackageSpec}, names::Dict{UU
         if !isdir(path)
             pkgerror("expected package $(err_rep(pkg)) to exist at path `$path`")
         end
-        deps, weakdeps = collect_project(pkg, path)
+        deps, weakdeps = collect_project(pkg, path, julia_version)
         deps_map[pkg.uuid] = deps
         weak_map[pkg.uuid] = weakdeps
     end
@@ -469,7 +469,7 @@ function resolve_versions!(env::EnvCache, registries::Vector{Registry.RegistryIn
     # compatibility
     if julia_version !== nothing
         # only set the manifest julia_version if ctx.julia_version is not nothing
-        env.manifest.julia_version = dropbuild(VERSION)
+        env.manifest.julia_version = dropbuild(julia_version)
         v = intersect(julia_version, get_compat_workspace(env, "julia"))
         if isempty(v)
             @warn "julia version requirement for project not satisfied" _module=nothing _file=nothing
@@ -493,7 +493,7 @@ function resolve_versions!(env::EnvCache, registries::Vector{Registry.RegistryIn
         end
     end
     # this also sets pkg.version for fixed packages
-    fixed = collect_fixed!(env, filter(!is_tracking_registry, pkgs), names)
+    fixed = collect_fixed!(env, filter(!is_tracking_registry, pkgs), names, julia_version)
     # non fixed packages are `add`ed by version: their version is either restricted or free
     # fixed packages are `dev`ed or `add`ed by repo
     # at this point, fixed packages have a version and `deps`

src/Pkg.jl

@@ -898,5 +898,6 @@ DEFAULT_IO[] = nothing
 Pkg.UPDATED_REGISTRY_THIS_SESSION[] = false
 PREV_ENV_PATH[] = ""
 Types.STDLIB[] = nothing
+empty!(Registry.REGISTRY_CACHE)
 
 end # module

src/Types.jl

@@ -585,6 +585,16 @@ function Context!(ctx::Context; kwargs...)
     for (k, v) in kwargs
         setfield!(ctx, k, v)
     end
+
+    # Highlight for logging purposes if julia_version is set to a different version than current VERSION
+    if haskey(kwargs, :julia_version) && ctx.julia_version !== nothing && ctx.julia_version != VERSION
+        Pkg.printpkgstyle(
+            ctx.io, :Context,
+            "Pkg is operating with julia_version set to `$(ctx.julia_version)`",
+            color = Base.warn_color()
+        )
+    end
+
     return ctx
 end
 

test/api.jl

@@ -308,8 +308,8 @@ end
     isolate(loaded_depot=true) do; mktempdir() do tempdir
         pathf = git_init_package(tempdir, joinpath(@__DIR__, "test_packages", "FarFuture"))
         pathp = git_init_package(tempdir, joinpath(@__DIR__, "test_packages", "FarPast"))
-        @test_throws "julia version requirement from Project.toml's compat section not satisfied for package" Pkg.add(path=pathf)
-        @test_throws "julia version requirement from Project.toml's compat section not satisfied for package" Pkg.add(path=pathp)
+        @test_throws "julia version requirement for package" Pkg.add(path=pathf)
+        @test_throws "julia version requirement for package" Pkg.add(path=pathp)
     end end
 end
 

test/pkg.jl

@@ -684,6 +684,27 @@ end
     end
 end
 
+if isdefined(Base.Filesystem, :delayed_delete_ref)
+    @testset "Pkg.gc for delayed deletes" begin
+        mktempdir() do root
+            dir = joinpath(root, "julia_delayed_deletes")
+            mkdir(dir)
+            testfile = joinpath(dir, "testfile")
+            write(testfile, "foo bar")
+            delayed_delete_ref_path = Base.Filesystem.delayed_delete_ref()
+            mkpath(delayed_delete_ref_path)
+            ref = tempname(delayed_delete_ref_path; cleanup = false)
+            write(ref, testfile)
+            @test isfile(testfile)
+            Pkg.gc()
+            @test !ispath(testfile)
+            @test !ispath(dir)
+            @test !ispath(ref)
+            @test !ispath(delayed_delete_ref_path) || !isempty(readdir(delayed_delete_ref_path))
+        end
+    end
+end
+
 #issue #876
 @testset "targets should survive add/rm" begin
     temp_pkg_dir() do project_path; cd_tempdir() do tmpdir