From 2d27adcee63be68c61d0c6c04225e918667aa20d Mon Sep 17 00:00:00 2001
From: Neven Sajko <4944410+nsajko@users.noreply.github.com>
Date: Tue, 1 Apr 2025 09:05:56 +0200
Subject: [PATCH 01/38] `append_c_digits`: typeassert `Int` to improve
 inference (#57950)

Makes the sysimage more resistant to method invalidation, when defining
a new `Integer` subtype with a right bitshift method.

(cherry picked from commit 69a22cf4bcaaf54e9bf08f2d4ed9e4e77f0ad1e4)
---
 base/intfuncs.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/base/intfuncs.jl b/base/intfuncs.jl
index 1bbab0224493e..1d31c6e2bdb42 100644
--- a/base/intfuncs.jl
+++ b/base/intfuncs.jl
@@ -845,7 +845,7 @@ function append_c_digits(olength::Int, digits::Unsigned, buf, pos::Int)
     while i >= 2
         d, c = divrem(digits, 0x64)
         digits = oftype(digits, d)
-        @inbounds d100 = _dec_d100[(c % Int) + 1]
+        @inbounds d100 = _dec_d100[(c % Int)::Int + 1]
         @inbounds buf[pos + i - 2] = d100 % UInt8
         @inbounds buf[pos + i - 1] = (d100 >> 0x8) % UInt8
         i -= 2

From 6182de7b498ad7a0fcfcd1ca5a629c511b207b93 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Thu, 3 Apr 2025 22:13:22 -0400
Subject: [PATCH 02/38] fix generated_body_to_codeinfo to avoid `string` (which
 is not always defined) (#57925)

Fixes a discrepancy between the code in C before #57230 and in Julia
afterwards, making sure to sequence these method definitions correctly.
Not sure how to write a reliable test since it is specific to when this
generated function is defined relative to the helpers used by this
thunk, but the issue/fix is visible with:

```
$ ./julia -e 'code_lowered(ntuple, (Returns{Nothing}, Val{1000000}))'
```

Fix #57301

(cherry picked from commit a3c48d742779fe3b866911b7477afe88d082c643)
---
 base/Base_compiler.jl | 44 ++++++++++++++++++++++++-------------------
 base/essentials.jl    |  2 ++
 base/expr.jl          |  3 ++-
 base/pointer.jl       |  2 --
 test/staged.jl        |  2 ++
 5 files changed, 31 insertions(+), 22 deletions(-)

diff --git a/base/Base_compiler.jl b/base/Base_compiler.jl
index 911659034a145..986f2fbe6b05c 100644
--- a/base/Base_compiler.jl
+++ b/base/Base_compiler.jl
@@ -158,6 +158,31 @@ if false
     println(io::IO, x...) = Core.println(io, x...)
 end
 
+## Load essential files and libraries
+include("essentials.jl")
+
+# Because lowering inserts direct references, it is mandatory for this binding
+# to exist before we start inferring code.
+function string end
+import Core: String
+
+# For OS specific stuff
+# We need to strcat things here, before strings are really defined
+function strcat(x::String, y::String)
+    out = ccall(:jl_alloc_string, Ref{String}, (Int,), Core.sizeof(x) + Core.sizeof(y))
+    gc_x = @_gc_preserve_begin(x)
+    gc_y = @_gc_preserve_begin(y)
+    gc_out = @_gc_preserve_begin(out)
+    out_ptr = unsafe_convert(Ptr{UInt8}, out)
+    unsafe_copyto!(out_ptr, unsafe_convert(Ptr{UInt8}, x), Core.sizeof(x))
+    unsafe_copyto!(out_ptr + Core.sizeof(x), unsafe_convert(Ptr{UInt8}, y), Core.sizeof(y))
+    @_gc_preserve_end(gc_x)
+    @_gc_preserve_end(gc_y)
+    @_gc_preserve_end(gc_out)
+    return out
+end
+
+
 """
     time_ns() -> UInt64
 
@@ -172,8 +197,6 @@ const _DOCS_ALIASING_WARNING = """
     Behavior can be unexpected when any mutated argument shares memory with any other argument.
 """
 
-## Load essential files and libraries
-include("essentials.jl")
 include("ctypes.jl")
 include("gcutils.jl")
 include("generator.jl")
@@ -284,7 +307,6 @@ include("rounding.jl")
 include("float.jl")
 
 # Lazy strings
-import Core: String
 include("strings/lazy.jl")
 
 function cld end
@@ -321,22 +343,6 @@ using .Order
 include("coreir.jl")
 include("invalidation.jl")
 
-# Because lowering inserts direct references, it is mandatory for this binding
-# to exist before we start inferring code.
-function string end
-
-# For OS specific stuff
-# We need to strcat things here, before strings are really defined
-function strcat(x::String, y::String)
-    out = ccall(:jl_alloc_string, Ref{String}, (Csize_t,), Core.sizeof(x) + Core.sizeof(y))
-    GC.@preserve x y out begin
-        out_ptr = unsafe_convert(Ptr{UInt8}, out)
-        unsafe_copyto!(out_ptr, unsafe_convert(Ptr{UInt8}, x), Core.sizeof(x))
-        unsafe_copyto!(out_ptr + Core.sizeof(x), unsafe_convert(Ptr{UInt8}, y), Core.sizeof(y))
-    end
-    return out
-end
-
 BUILDROOT::String = ""
 DATAROOT::String = ""
 const DL_LOAD_PATH = String[]
diff --git a/base/essentials.jl b/base/essentials.jl
index 93c36968adb7c..5068acf24cbc1 100644
--- a/base/essentials.jl
+++ b/base/essentials.jl
@@ -690,6 +690,8 @@ cconvert(::Type{<:Ptr}, x) = x # but defer the conversion to Ptr to unsafe_conve
 unsafe_convert(::Type{T}, x::T) where {T} = x # unsafe_convert (like convert) defaults to assuming the convert occurred
 unsafe_convert(::Type{T}, x::T) where {T<:Ptr} = x  # to resolve ambiguity with the next method
 unsafe_convert(::Type{P}, x::Ptr) where {P<:Ptr} = convert(P, x)
+unsafe_convert(::Type{Ptr{UInt8}}, s::String) = ccall(:jl_string_ptr, Ptr{UInt8}, (Any,), s)
+unsafe_convert(::Type{Ptr{Int8}}, s::String) = ccall(:jl_string_ptr, Ptr{Int8}, (Any,), s)
 
 """
     reinterpret(::Type{Out}, x::In)
diff --git a/base/expr.jl b/base/expr.jl
index dd89f9e64abd4..ba66198822eca 100644
--- a/base/expr.jl
+++ b/base/expr.jl
@@ -1664,7 +1664,8 @@ function generated_body_to_codeinfo(ex::Expr, defmod::Module, isva::Bool)
     ci = ccall(:jl_expand, Any, (Any, Any), ex, defmod)
     if !isa(ci, CodeInfo)
         if isa(ci, Expr) && ci.head === :error
-            error("syntax: $(ci.args[1])")
+            msg = ci.args[1]
+            error(msg isa String ? strcat("syntax: ", msg) : msg)
         end
         error("The function body AST defined by this @generated function is not pure. This likely means it contains a closure, a comprehension or a generator.")
     end
diff --git a/base/pointer.jl b/base/pointer.jl
index de2f413d8f881..97b9bf0e01732 100644
--- a/base/pointer.jl
+++ b/base/pointer.jl
@@ -59,8 +59,6 @@ cconvert(::Type{Ptr{UInt8}}, s::AbstractString) = String(s)
 cconvert(::Type{Ptr{Int8}}, s::AbstractString) = String(s)
 unsafe_convert(::Type{Ptr{UInt8}}, x::Symbol) = ccall(:jl_symbol_name, Ptr{UInt8}, (Any,), x)
 unsafe_convert(::Type{Ptr{Int8}}, x::Symbol) = ccall(:jl_symbol_name, Ptr{Int8}, (Any,), x)
-unsafe_convert(::Type{Ptr{UInt8}}, s::String) = ccall(:jl_string_ptr, Ptr{UInt8}, (Any,), s)
-unsafe_convert(::Type{Ptr{Int8}}, s::String) = ccall(:jl_string_ptr, Ptr{Int8}, (Any,), s)
 
 cconvert(::Type{<:Ptr}, a::Array) = getfield(a, :ref)
 unsafe_convert(::Type{Ptr{S}}, a::AbstractArray{T}) where {S,T} = convert(Ptr{S}, unsafe_convert(Ptr{T}, a))
diff --git a/test/staged.jl b/test/staged.jl
index d416b0f9a22f0..4fb5d03331711 100644
--- a/test/staged.jl
+++ b/test/staged.jl
@@ -477,3 +477,5 @@ module GeneratedScope57417
     end
     @test g() == 1
 end
+
+@test_throws "syntax: expression too large" code_lowered(ntuple, (Returns{Nothing}, Val{1000000}))

From 787d9342b8368732ee4e6c9a0f1b219d84565799 Mon Sep 17 00:00:00 2001
From: Neven Sajko <4944410+nsajko@users.noreply.github.com>
Date: Fri, 4 Apr 2025 04:13:40 +0200
Subject: [PATCH 03/38] fix `nextpow`, `prevpow` for types without `typemax`
 (#49669)

Without this change `prevpow` and `nextpow` fail for, e.g., `BigInt`;
incorrectly throwing a `MethodError`. For example, calls like
`prevpow(3, big"10")` or `nextpow(3, big"10")` fail.

The issue is that the code incorrectly assumes the existence of a
`typemax` method.

Another issue was a missing promote for the arguments of a
`mul_with_overflow` call.

Fixes #57906

(cherry picked from commit 3627a85749e4aa8197edb56dd93d1b21fd54dbe8)
---
 base/intfuncs.jl |  8 +++++---
 test/intfuncs.jl | 17 ++++++++++++++++-
 2 files changed, 21 insertions(+), 4 deletions(-)

diff --git a/base/intfuncs.jl b/base/intfuncs.jl
index 1d31c6e2bdb42..552a51c33fb12 100644
--- a/base/intfuncs.jl
+++ b/base/intfuncs.jl
@@ -570,7 +570,8 @@ function nextpow(a::Real, x::Real)
     n = ceil(Integer,log(a, x))
     # round-off error of log can go either direction, so need some checks
     p = a^(n-1)
-    x > typemax(p) && throw(DomainError(x,"argument is beyond the range of type of the base"))
+    hastypemax(typeof(p)) && x > typemax(p) &&
+        throw(DomainError(x,"argument is beyond the range of type of the base"))
     p >= x && return p
     wp = a^n
     wp > p || throw(OverflowError("result is beyond the range of type of the base"))
@@ -611,9 +612,10 @@ function prevpow(a::T, x::Real) where T <: Real
     n = floor(Integer,log(a, x))
     # round-off error of log can go either direction, so need some checks
     p = a^n
-    x > typemax(p) && throw(DomainError(x,"argument is beyond the range of type of the base"))
+    hastypemax(typeof(p)) && x > typemax(p) &&
+        throw(DomainError(x,"argument is beyond the range of type of the base"))
     if a isa Integer
-        wp, overflow = mul_with_overflow(a, p)
+        wp, overflow = mul_with_overflow(promote(a, p)...)
         wp <= x && !overflow && return wp
     else
         wp = a^(n+1)
diff --git a/test/intfuncs.jl b/test/intfuncs.jl
index 38f29344d2f30..adcfee2a050dd 100644
--- a/test/intfuncs.jl
+++ b/test/intfuncs.jl
@@ -326,6 +326,14 @@ end
 end
 
 @testset "nextpow/prevpow" begin
+    fs = (prevpow, nextpow)
+    types = (Int8, BigInt, BigFloat)
+    for f ∈ fs, P ∈ types, R ∈ types, p ∈ 1:20, r ∈ 2:5
+        q = P(p)
+        n = R(r)
+        @test f(r, p) == f(n, q)
+    end
+
     @test nextpow(2, 3) == 4
     @test nextpow(2, 4) == 4
     @test nextpow(2, 7) == 8
@@ -339,7 +347,14 @@ end
     @test prevpow(10, 101.0) === 100
     @test prevpow(10.0, 101) === 100.0
     @test_throws DomainError prevpow(0, 3)
-    @test_throws DomainError prevpow(0, 3)
+    @test_throws DomainError prevpow(3, 0)
+
+    # "argument is beyond the range of type of the base"
+    @test_throws DomainError prevpow(Int8(3), 243)
+    @test_throws DomainError nextpow(Int8(3), 243)
+
+    # "result is beyond the range of type of the base"
+    @test_throws OverflowError nextpow(Int8(3), 82)
 end
 
 @testset "ndigits/ndigits0z" begin

From 1e436b103dd813a4adc5c4cdc8e03ad10fdb42df Mon Sep 17 00:00:00 2001
From: Heptazhou <zhou@0h7z.com>
Date: Sat, 5 Apr 2025 19:44:11 +0000
Subject: [PATCH 04/38] Backport #57423 to v1.12 (#58004)

Ref: #57423.
---
 NEWS.md                   |  2 +-
 stdlib/UUIDs/src/UUIDs.jl | 10 +++++-----
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/NEWS.md b/NEWS.md
index c421b7eeb3f4e..655c670c1c947 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -103,7 +103,7 @@ New library functions
 * The new `isfull(c::Channel)` function can be used to check if `put!(c, some_value)` will block ([#53159]).
 * `waitany(tasks; throw=false)` and `waitall(tasks; failfast=false, throw=false)` which wait for multiple tasks
   at once ([#53341]).
-* `uuid7()` creates an RFC 9652 compliant UUID with version 7 ([#54834]).
+* `uuid7()` creates an RFC 9562 compliant UUID with version 7 ([#54834]).
 * `insertdims(array; dims)` inserts singleton dimensions into an array --- the inverse operation of
   `dropdims` ([#45793]).
 * A new `Fix` type generalizes `Fix1/Fix2` for fixing a single argument ([#54653]).
diff --git a/stdlib/UUIDs/src/UUIDs.jl b/stdlib/UUIDs/src/UUIDs.jl
index e3f5f812ef6e2..e29cf3ff7597e 100644
--- a/stdlib/UUIDs/src/UUIDs.jl
+++ b/stdlib/UUIDs/src/UUIDs.jl
@@ -18,7 +18,7 @@ import Base: UUID
     uuid_version(u::UUID) -> Int
 
 Inspects the given UUID and returns its version
-(see [RFC 4122](https://www.ietf.org/rfc/rfc4122)).
+(see [RFC 4122](https://tools.ietf.org/html/rfc4122)).
 
 # Examples
 ```jldoctest
@@ -39,7 +39,7 @@ const namespace_x500 = UUID(0x6ba7b8149dad11d180b400c04fd430c8) # 6ba7b814-9dad-
     uuid1([rng::AbstractRNG]) -> UUID
 
 Generates a version 1 (time-based) universally unique identifier (UUID), as specified
-by [RFC 4122](https://www.ietf.org/rfc/rfc4122). Note that the Node ID is randomly generated (does not identify the host)
+by [RFC 4122](https://tools.ietf.org/html/rfc4122). Note that the Node ID is randomly generated (does not identify the host)
 according to section 4.5 of the RFC.
 
 The default rng used by `uuid1` is not `Random.default_rng()` and every invocation of `uuid1()` without
@@ -92,7 +92,7 @@ end
     uuid4([rng::AbstractRNG]) -> UUID
 
 Generates a version 4 (random or pseudo-random) universally unique identifier (UUID),
-as specified by [RFC 4122](https://www.ietf.org/rfc/rfc4122).
+as specified by [RFC 4122](https://tools.ietf.org/html/rfc4122).
 
 The default rng used by `uuid4` is not `Random.default_rng()` and every invocation of `uuid4()` without
 an argument should be expected to return a unique identifier. Importantly, the outputs of
@@ -124,7 +124,7 @@ end
     uuid5(ns::UUID, name::String) -> UUID
 
 Generates a version 5 (namespace and domain-based) universally unique identifier (UUID),
-as specified by RFC 4122.
+as specified by [RFC 4122](https://tools.ietf.org/html/rfc4122).
 
 !!! compat "Julia 1.1"
     This function requires at least Julia 1.1.
@@ -165,7 +165,7 @@ end
     uuid7([rng::AbstractRNG]) -> UUID
 
 Generates a version 7 (random or pseudo-random) universally unique identifier (UUID),
-as specified by [RFC 9652](https://www.rfc-editor.org/rfc/rfc9562).
+as specified by [RFC 9562](https://tools.ietf.org/html/rfc9562).
 
 The default rng used by `uuid7` is not `Random.default_rng()` and every invocation of `uuid7()` without
 an argument should be expected to return a unique identifier. Importantly, the outputs of

From fd213c31a50456955a27481b8d8fbcf208e52128 Mon Sep 17 00:00:00 2001
From: DilumAluthgeBot <43731525+DilumAluthgeBot@users.noreply.github.com>
Date: Mon, 7 Apr 2025 15:17:40 -0400
Subject: [PATCH 05/38] =?UTF-8?q?=F0=9F=A4=96=20[backports-release-1.12]?=
 =?UTF-8?q?=20Bump=20the=20LinearAlgebra=20stdlib=20from=20f0f7a46=20to=20?=
 =?UTF-8?q?4e7c3f4=20(#58031)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Stdlib: LinearAlgebra
URL: https://github.com/JuliaLang/LinearAlgebra.jl.git
Stdlib branch: release-1.12
Julia branch: backports-release-1.12
Old commit: f0f7a46
New commit: 4e7c3f4
Julia version: 1.12.0-beta1
LinearAlgebra version: 1.12.0
Bump invoked by: @dkarrasch
Powered by:
[BumpStdlibs.jl](https://github.com/JuliaLang/BumpStdlibs.jl)

Diff:
https://github.com/JuliaLang/LinearAlgebra.jl/compare/f0f7a46063ae60a794e3ae6aa2910cfc90b41760...4e7c3f40316a956119ac419a97c4b8aad7a17e6c

```
$ git log --oneline f0f7a46..4e7c3f4
4e7c3f4 Backports release v1.12 (#1237)
e909af2 Before running any `@allocations` tests, run the workload
2ce3f73 Move `alg` to a keyword argument in symmetric eigen (#1214)
4f203c3 Make use of `mul` indirection (#1215)
```

Co-authored-by: dkarrasch <26658441+dkarrasch@users.noreply.github.com>
---
 .../md5                                                         | 1 +
 .../sha512                                                      | 1 +
 .../md5                                                         | 1 -
 .../sha512                                                      | 1 -
 stdlib/LinearAlgebra.version                                    | 2 +-
 5 files changed, 3 insertions(+), 3 deletions(-)
 create mode 100644 deps/checksums/LinearAlgebra-4e7c3f40316a956119ac419a97c4b8aad7a17e6c.tar.gz/md5
 create mode 100644 deps/checksums/LinearAlgebra-4e7c3f40316a956119ac419a97c4b8aad7a17e6c.tar.gz/sha512
 delete mode 100644 deps/checksums/LinearAlgebra-f0f7a46063ae60a794e3ae6aa2910cfc90b41760.tar.gz/md5
 delete mode 100644 deps/checksums/LinearAlgebra-f0f7a46063ae60a794e3ae6aa2910cfc90b41760.tar.gz/sha512

diff --git a/deps/checksums/LinearAlgebra-4e7c3f40316a956119ac419a97c4b8aad7a17e6c.tar.gz/md5 b/deps/checksums/LinearAlgebra-4e7c3f40316a956119ac419a97c4b8aad7a17e6c.tar.gz/md5
new file mode 100644
index 0000000000000..d96f9c1708089
--- /dev/null
+++ b/deps/checksums/LinearAlgebra-4e7c3f40316a956119ac419a97c4b8aad7a17e6c.tar.gz/md5
@@ -0,0 +1 @@
+a622992fb673fc417e588f262b679b00
diff --git a/deps/checksums/LinearAlgebra-4e7c3f40316a956119ac419a97c4b8aad7a17e6c.tar.gz/sha512 b/deps/checksums/LinearAlgebra-4e7c3f40316a956119ac419a97c4b8aad7a17e6c.tar.gz/sha512
new file mode 100644
index 0000000000000..ba63ad3cb9264
--- /dev/null
+++ b/deps/checksums/LinearAlgebra-4e7c3f40316a956119ac419a97c4b8aad7a17e6c.tar.gz/sha512
@@ -0,0 +1 @@
+48ce73841c0a766d0e0310beac77033a694f7fcc30b939241d0c04f35f079dd8f932f1973c002180f178a9f2bdf99535f09bea4f20151e09948f21549bfa1490
diff --git a/deps/checksums/LinearAlgebra-f0f7a46063ae60a794e3ae6aa2910cfc90b41760.tar.gz/md5 b/deps/checksums/LinearAlgebra-f0f7a46063ae60a794e3ae6aa2910cfc90b41760.tar.gz/md5
deleted file mode 100644
index 712005f2dcb7f..0000000000000
--- a/deps/checksums/LinearAlgebra-f0f7a46063ae60a794e3ae6aa2910cfc90b41760.tar.gz/md5
+++ /dev/null
@@ -1 +0,0 @@
-5b6db0a9e4e75f998b63ef9b3f62005c
diff --git a/deps/checksums/LinearAlgebra-f0f7a46063ae60a794e3ae6aa2910cfc90b41760.tar.gz/sha512 b/deps/checksums/LinearAlgebra-f0f7a46063ae60a794e3ae6aa2910cfc90b41760.tar.gz/sha512
deleted file mode 100644
index 42e33bc1a239c..0000000000000
--- a/deps/checksums/LinearAlgebra-f0f7a46063ae60a794e3ae6aa2910cfc90b41760.tar.gz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-b1bd5744395f692c5902c7074a4e7d3a9cfd7b1905bccdf72b77602ab10d3c1b9a8eb45eac358442da3afc1d26f2e4f4d56f40a0465a70e1d962f0a6a259657e
diff --git a/stdlib/LinearAlgebra.version b/stdlib/LinearAlgebra.version
index acc660eb22f59..0aa71a8804660 100644
--- a/stdlib/LinearAlgebra.version
+++ b/stdlib/LinearAlgebra.version
@@ -1,4 +1,4 @@
 LINEARALGEBRA_BRANCH = release-1.12
-LINEARALGEBRA_SHA1 = f0f7a46063ae60a794e3ae6aa2910cfc90b41760
+LINEARALGEBRA_SHA1 = 4e7c3f40316a956119ac419a97c4b8aad7a17e6c
 LINEARALGEBRA_GIT_URL := https://github.com/JuliaLang/LinearAlgebra.jl.git
 LINEARALGEBRA_TAR_URL = https://api.github.com/repos/JuliaLang/LinearAlgebra.jl/tarball/$1

From 956422ee1e5606129fb652521fbf33156bbf723a Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Tue, 8 Apr 2025 14:17:02 -0400
Subject: [PATCH 06/38] inference: re-enable inference overload for basic
 statements (#58027)

After JuliaLang/julia#55575, inference for basic statements got inlined
into `typeinf_local`. But external abstract interpreters like JET.jl
need to overload this inference to customize this behavior. So this
commit extracts the inlined inference logic back out into a separate
`abstract_eval_basic_statement` method.
---
 Compiler/src/abstractinterpretation.jl | 197 +++++++++++++++----------
 1 file changed, 115 insertions(+), 82 deletions(-)

diff --git a/Compiler/src/abstractinterpretation.jl b/Compiler/src/abstractinterpretation.jl
index 2a535cb20b4d0..ee95c105691d9 100644
--- a/Compiler/src/abstractinterpretation.jl
+++ b/Compiler/src/abstractinterpretation.jl
@@ -3659,6 +3659,107 @@ function abstract_eval_ssavalue(s::SSAValue, ssavaluetypes::Vector{Any})
     return typ
 end
 
+struct AbstractEvalBasicStatementResult
+    rt
+    exct
+    effects::Union{Nothing,Effects}
+    changes::Union{Nothing,StateUpdate}
+    refinements # ::Union{Nothing,SlotRefinement,Vector{Any}}
+    currsaw_latestworld::Bool
+    function AbstractEvalBasicStatementResult(rt, exct, effects::Union{Nothing,Effects},
+        changes::Union{Nothing,StateUpdate}, refinements, currsaw_latestworld::Bool)
+        @nospecialize rt exct refinements
+        return new(rt, exct, effects, changes, refinements, currsaw_latestworld)
+    end
+end
+
+function abstract_eval_basic_statement(interp::AbstractInterpreter, @nospecialize(stmt), sstate::StatementState, frame::InferenceState,
+                                       result::Union{Nothing,Future{RTEffects}}=nothing)
+    rt = nothing
+    exct = Bottom
+    changes = nothing
+    refinements = nothing
+    effects = nothing
+    currsaw_latestworld = sstate.saw_latestworld
+    if result !== nothing
+        @goto injectresult
+    end
+    if isa(stmt, NewvarNode)
+        changes = StateUpdate(stmt.slot, VarState(Bottom, true))
+    elseif isa(stmt, PhiNode)
+        add_curr_ssaflag!(frame, IR_FLAGS_REMOVABLE)
+        # Implement convergence for PhiNodes. In particular, PhiNodes need to tmerge over
+        # the incoming values from all iterations, but `abstract_eval_phi` will only tmerge
+        # over the first and last iterations. By tmerging in the current old_rt, we ensure that
+        # we will not lose an intermediate value.
+        rt = abstract_eval_phi(interp, stmt, sstate, frame)
+        old_rt = frame.ssavaluetypes[frame.currpc]
+        rt = old_rt === NOT_FOUND ? rt : tmerge(typeinf_lattice(interp), old_rt, rt)
+    else
+        lhs = nothing
+        if isexpr(stmt, :(=))
+            lhs = stmt.args[1]
+            stmt = stmt.args[2]
+        end
+        if !isa(stmt, Expr)
+            (; rt, exct, effects, refinements) = abstract_eval_special_value(interp, stmt, sstate, frame)
+        else
+            hd = stmt.head
+            if hd === :method
+                fname = stmt.args[1]
+                if isa(fname, SlotNumber)
+                    changes = StateUpdate(fname, VarState(Any, false))
+                end
+            elseif (hd === :code_coverage_effect ||
+                    # :boundscheck can be narrowed to Bool
+                    (hd !== :boundscheck && is_meta_expr(stmt)))
+                rt = Nothing
+            elseif hd === :latestworld
+                currsaw_latestworld = true
+                rt = Nothing
+            else
+                result = abstract_eval_statement_expr(interp, stmt, sstate, frame)::Future{RTEffects}
+                if !isready(result) || !isempty(frame.tasks)
+                    return result
+
+                    @label injectresult
+                    # reload local variables
+                    lhs = nothing
+                    if isexpr(stmt, :(=))
+                        lhs = stmt.args[1]
+                        stmt = stmt.args[2]
+                    end
+                end
+                result = result[]
+                (; rt, exct, effects, refinements) = result
+                if effects.noub === NOUB_IF_NOINBOUNDS
+                    if has_curr_ssaflag(frame, IR_FLAG_INBOUNDS)
+                        effects = Effects(effects; noub=ALWAYS_FALSE)
+                    elseif !propagate_inbounds(frame)
+                        # The callee read our inbounds flag, but unless we propagate inbounds,
+                        # we ourselves don't read our parent's inbounds.
+                        effects = Effects(effects; noub=ALWAYS_TRUE)
+                    end
+                end
+                @assert !isa(rt, TypeVar) "unhandled TypeVar"
+                rt = maybe_singleton_const(rt)
+                if !isempty(frame.pclimitations)
+                    if rt isa Const || rt === Union{}
+                        empty!(frame.pclimitations)
+                    else
+                        rt = LimitedAccuracy(rt, frame.pclimitations)
+                        frame.pclimitations = IdSet{InferenceState}()
+                    end
+                end
+            end
+        end
+        if lhs !== nothing && rt !== Bottom
+            changes = StateUpdate(lhs::SlotNumber, VarState(rt, false))
+        end
+    end
+    return AbstractEvalBasicStatementResult(rt, exct, effects, changes, refinements, currsaw_latestworld)
+end
+
 struct BestguessInfo{Interp<:AbstractInterpreter}
     interp::Interp
     bestguess
@@ -3940,14 +4041,16 @@ end
 
 # make as much progress on `frame` as possible (without handling cycles)
 struct CurrentState
-    result::Future
+    result::Future{RTEffects}
     currstate::VarTable
     currsaw_latestworld::Bool
     bbstart::Int
     bbend::Int
-    CurrentState(result::Future, currstate::VarTable, currsaw_latestworld::Bool, bbstart::Int, bbend::Int) = new(result, currstate, currsaw_latestworld, bbstart, bbend)
+    CurrentState(result::Future{RTEffects}, currstate::VarTable, currsaw_latestworld::Bool, bbstart::Int, bbend::Int) =
+        new(result, currstate, currsaw_latestworld, bbstart, bbend)
     CurrentState() = new()
 end
+
 function typeinf_local(interp::AbstractInterpreter, frame::InferenceState, nextresult::CurrentState)
     @assert !is_inferred(frame)
     W = frame.ip
@@ -3966,7 +4069,9 @@ function typeinf_local(interp::AbstractInterpreter, frame::InferenceState, nextr
         bbend = nextresult.bbend
         currstate = nextresult.currstate
         currsaw_latestworld = nextresult.currsaw_latestworld
-        @goto injectresult
+        stmt = frame.src.code[currpc]
+        result = abstract_eval_basic_statement(interp, stmt, StatementState(currstate, currsaw_latestworld), frame, nextresult.result)
+        @goto injected_result
     end
 
     if currbb != 1
@@ -4119,87 +4224,15 @@ function typeinf_local(interp::AbstractInterpreter, frame::InferenceState, nextr
             end
             # Process non control-flow statements
             @assert isempty(frame.tasks)
-            rt = nothing
-            exct = Bottom
-            changes = nothing
-            refinements = nothing
-            effects = nothing
-            if isa(stmt, NewvarNode)
-                changes = StateUpdate(stmt.slot, VarState(Bottom, true))
-            elseif isa(stmt, PhiNode)
-                add_curr_ssaflag!(frame, IR_FLAGS_REMOVABLE)
-                # Implement convergence for PhiNodes. In particular, PhiNodes need to tmerge over
-                # the incoming values from all iterations, but `abstract_eval_phi` will only tmerge
-                # over the first and last iterations. By tmerging in the current old_rt, we ensure that
-                # we will not lose an intermediate value.
-                rt = abstract_eval_phi(interp, stmt, StatementState(currstate, currsaw_latestworld), frame)
-                old_rt = frame.ssavaluetypes[currpc]
-                rt = old_rt === NOT_FOUND ? rt : tmerge(typeinf_lattice(interp), old_rt, rt)
+            sstate = StatementState(currstate, currsaw_latestworld)
+            result = abstract_eval_basic_statement(interp, stmt, sstate, frame)
+            if result isa Future{RTEffects}
+                return CurrentState(result, currstate, currsaw_latestworld, bbstart, bbend)
             else
-                lhs = nothing
-                if isexpr(stmt, :(=))
-                    lhs = stmt.args[1]
-                    stmt = stmt.args[2]
-                end
-                if !isa(stmt, Expr)
-                    (; rt, exct, effects, refinements) = abstract_eval_special_value(interp, stmt, StatementState(currstate, currsaw_latestworld), frame)
-                else
-                    hd = stmt.head
-                    if hd === :method
-                        fname = stmt.args[1]
-                        if isa(fname, SlotNumber)
-                            changes = StateUpdate(fname, VarState(Any, false))
-                        end
-                    elseif (hd === :code_coverage_effect || (
-                            hd !== :boundscheck && # :boundscheck can be narrowed to Bool
-                            is_meta_expr(stmt)))
-                        rt = Nothing
-                    elseif hd === :latestworld
-                        currsaw_latestworld = true
-                        rt = Nothing
-                    else
-                        result = abstract_eval_statement_expr(interp, stmt, StatementState(currstate, currsaw_latestworld), frame)::Future
-                        if !isready(result) || !isempty(frame.tasks)
-                            return CurrentState(result, currstate, currsaw_latestworld, bbstart, bbend)
-                            @label injectresult
-                            # reload local variables
-                            stmt = frame.src.code[currpc]
-                            changes = nothing
-                            lhs = nothing
-                            if isexpr(stmt, :(=))
-                                lhs = stmt.args[1]
-                                stmt = stmt.args[2]
-                            end
-                            result = nextresult.result::Future{RTEffects}
-                        end
-                        result = result[]
-                        (; rt, exct, effects, refinements) = result
-                        if effects.noub === NOUB_IF_NOINBOUNDS
-                            if has_curr_ssaflag(frame, IR_FLAG_INBOUNDS)
-                                effects = Effects(effects; noub=ALWAYS_FALSE)
-                            elseif !propagate_inbounds(frame)
-                                # The callee read our inbounds flag, but unless we propagate inbounds,
-                                # we ourselves don't read our parent's inbounds.
-                                effects = Effects(effects; noub=ALWAYS_TRUE)
-                            end
-                        end
-                        @assert !isa(rt, TypeVar) "unhandled TypeVar"
-                        rt = maybe_singleton_const(rt)
-                        if !isempty(frame.pclimitations)
-                            if rt isa Const || rt === Union{}
-                                empty!(frame.pclimitations)
-                            else
-                                rt = LimitedAccuracy(rt, frame.pclimitations)
-                                frame.pclimitations = IdSet{InferenceState}()
-                            end
-                        end
-                    end
-                end
-                effects === nothing || merge_override_effects!(interp, effects, frame)
-                if lhs !== nothing && rt !== Bottom
-                    changes = StateUpdate(lhs::SlotNumber, VarState(rt, false))
-                end
+                @label injected_result
+                (; rt, exct, effects, changes, refinements, currsaw_latestworld) = result
             end
+            effects === nothing || merge_override_effects!(interp, effects, frame)
             if !has_curr_ssaflag(frame, IR_FLAG_NOTHROW)
                 if exct !== Union{}
                     update_exc_bestguess!(interp, exct, frame)

From af93514fc7409d8015cadfe0e735e56899a393b1 Mon Sep 17 00:00:00 2001
From: Tim Holy <tim.holy@gmail.com>
Date: Fri, 4 Apr 2025 05:46:27 -0500
Subject: [PATCH 07/38] Add matches for invoke invalidations (#57999)

Edge invalidations of the form

```julia
Package InvalidA:
module InvalidA
f(::Integer) = 1
invokesfs(x) = invoke(f, Tuple{Signed}, x)
end

Package InvalidB:
module InvalidB
using InvalidA
InvalidA.invokesfs(1)   # precompile
end
```

used as

```julia
using PkgA
InvalidA.f(::Signed) = 4
using PkgB
```

did not formerly attribute a "cause":

```
...
Tuple{typeof(InvalidA.f), Signed}
 "insert_backedges_callee"
 CodeInstance for MethodInstance for InvalidA.invokesfs(::Int64)
 nothing
...
```

This fills in the new method that replaced the previous dispatch.

---------

Co-authored-by: Jameson Nash <vtjnash@gmail.com>
(cherry picked from commit 15e0debb62eb0445352919681315ed78c07e7919)
---
 base/staticdata.jl | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

diff --git a/base/staticdata.jl b/base/staticdata.jl
index 94526cc4f7bd3..d51e7892bbe56 100644
--- a/base/staticdata.jl
+++ b/base/staticdata.jl
@@ -162,8 +162,7 @@ function verify_method(codeinst::CodeInstance, stack::Vector{CodeInstance}, visi
                 else
                     meth = callee::Method
                 end
-                min_valid2, max_valid2 = verify_invokesig(edge, meth, world)
-                matches = nothing
+                min_valid2, max_valid2, matches = verify_invokesig(edge, meth, world)
                 j += 2
             end
             if minworld < min_valid2
@@ -295,6 +294,7 @@ end
 function verify_invokesig(@nospecialize(invokesig), expected::Method, world::UInt)
     @assert invokesig isa Type
     local minworld::UInt, maxworld::UInt
+    matched = nothing
     if invokesig === expected.sig
         # the invoke match is `expected` for `expected->sig`, unless `expected` is invalid
         minworld = expected.primary_world
@@ -314,12 +314,15 @@ function verify_invokesig(@nospecialize(invokesig), expected::Method, world::UIn
             minworld, maxworld = valid_worlds.min_world, valid_worlds.max_world
             if matched === nothing
                 maxworld = 0
-            elseif matched.method != expected
-                maxworld = 0
+            else
+                matched = Any[matched.method]
+                if matched[] !== expected
+                    maxworld = 0
+                end
             end
         end
     end
-    return minworld, maxworld
+    return minworld, maxworld, matched
 end
 
 end # module StaticData

From a210129fe400b43856d98a1e131135afd64df31e Mon Sep 17 00:00:00 2001
From: Ian Butterworth <i.r.butterworth@gmail.com>
Date: Fri, 4 Apr 2025 09:30:32 -0400
Subject: [PATCH 08/38] Logging: Improve threadsafety (#57591)

Closes https://github.com/JuliaLang/julia/issues/57376
Closes https://github.com/JuliaLang/julia/issues/34037

- Adds a lock in `SimpleLogger` and `ConsoleLogger` for use on maxlog
tracking and stream writes to improve threadsafety.
Closely similar to https://github.com/JuliaLang/julia/pull/54497

- Turns the internal `_min_enabled_level` into a `Threads.Atomic`. There
are [some direct
interactions](https://juliahub.com/ui/Search?type=code&q=_min_enabled_level&w=true)
to this internal in the ecosystem, but they should still work
```
julia> Base.CoreLogging._min_enabled_level[] = Logging.Info+1
LogLevel(1)
```

- Brings tests over from https://github.com/JuliaLang/julia/pull/57448

Performance seems highly similar:

### Master
```
julia> @time for i in 1:10000
          @info "foo" maxlog=10000000
       end
[ Info: foo
...
  0.481446 seconds (1.33 M allocations: 89.226 MiB, 0.49% gc time)
```

### This PR
```
  0.477235 seconds (1.31 M allocations: 79.002 MiB, 1.77% gc time)
```

(cherry picked from commit 9af96508e9715e22154fc7b5a7283ad41d23765a)
---
 base/logging/ConsoleLogger.jl       | 21 +++++++++-----
 base/logging/logging.jl             | 36 ++++++++++++++++--------
 stdlib/Logging/test/runtests.jl     | 43 +++++++++++++++++++++++++++++
 stdlib/Logging/test/threads_exec.jl | 13 +++++++++
 stdlib/Test/src/logging.jl          |  2 +-
 5 files changed, 95 insertions(+), 20 deletions(-)
 create mode 100644 stdlib/Logging/test/threads_exec.jl

diff --git a/base/logging/ConsoleLogger.jl b/base/logging/ConsoleLogger.jl
index 818b2272b773c..8766d0ae56331 100644
--- a/base/logging/ConsoleLogger.jl
+++ b/base/logging/ConsoleLogger.jl
@@ -9,6 +9,9 @@ interactive work with the Julia REPL.
 
 Log levels less than `min_level` are filtered out.
 
+This Logger is thread-safe, with locks for both orchestration of message
+limits i.e. `maxlog`, and writes to the stream.
+
 Message formatting can be controlled by setting keyword arguments:
 
 * `meta_formatter` is a function which takes the log event metadata
@@ -24,6 +27,7 @@ Message formatting can be controlled by setting keyword arguments:
 """
 struct ConsoleLogger <: AbstractLogger
     stream::IO
+    lock::ReentrantLock # do not log within this lock
     min_level::LogLevel
     meta_formatter
     show_limited::Bool
@@ -33,19 +37,19 @@ end
 function ConsoleLogger(stream::IO, min_level=Info;
                        meta_formatter=default_metafmt, show_limited=true,
                        right_justify=0)
-    ConsoleLogger(stream, min_level, meta_formatter,
+    ConsoleLogger(stream, ReentrantLock(), min_level, meta_formatter,
                   show_limited, right_justify, Dict{Any,Int}())
 end
 function ConsoleLogger(min_level=Info;
                        meta_formatter=default_metafmt, show_limited=true,
                        right_justify=0)
-    ConsoleLogger(closed_stream, min_level, meta_formatter,
+    ConsoleLogger(closed_stream, ReentrantLock(), min_level, meta_formatter,
                   show_limited, right_justify, Dict{Any,Int}())
 end
 
 
 shouldlog(logger::ConsoleLogger, level, _module, group, id) =
-    get(logger.message_limits, id, 1) > 0
+    @lock logger.lock get(logger.message_limits, id, 1) > 0
 
 min_enabled_level(logger::ConsoleLogger) = logger.min_level
 
@@ -109,9 +113,11 @@ function handle_message(logger::ConsoleLogger, level::LogLevel, message, _module
     hasmaxlog = haskey(kwargs, :maxlog) ? 1 : 0
     maxlog = get(kwargs, :maxlog, nothing)
     if maxlog isa Core.BuiltinInts
-        remaining = get!(logger.message_limits, id, Int(maxlog)::Int)
-        logger.message_limits[id] = remaining - 1
-        remaining > 0 || return
+        @lock logger.lock begin
+            remaining = get!(logger.message_limits, id, Int(maxlog)::Int)
+            remaining == 0 && return
+            logger.message_limits[id] = remaining - 1
+        end
     end
 
     # Generate a text representation of the message and all key value pairs,
@@ -184,6 +190,7 @@ function handle_message(logger::ConsoleLogger, level::LogLevel, message, _module
         println(iob)
     end
 
-    write(stream, take!(buf))
+    b = take!(buf)
+    @lock logger.lock write(stream, b)
     nothing
 end
diff --git a/base/logging/logging.jl b/base/logging/logging.jl
index a1a8417bcb388..c4a3d21fed982 100644
--- a/base/logging/logging.jl
+++ b/base/logging/logging.jl
@@ -132,6 +132,7 @@ isless(a::LogLevel, b::LogLevel) = isless(a.level, b.level)
 +(level::LogLevel, inc::Integer) = LogLevel(level.level+inc)
 -(level::LogLevel, inc::Integer) = LogLevel(level.level-inc)
 convert(::Type{LogLevel}, level::Integer) = LogLevel(level)
+convert(::Type{Int32}, level::LogLevel) = level.level
 
 """
     BelowMinLevel
@@ -171,7 +172,8 @@ Alias for [`LogLevel(1_000_001)`](@ref LogLevel).
 const AboveMaxLevel = LogLevel( 1000001)
 
 # Global log limiting mechanism for super fast but inflexible global log limiting.
-const _min_enabled_level = Ref{LogLevel}(Debug)
+# Atomic ensures that the value is always consistent across threads.
+const _min_enabled_level = Threads.Atomic{Int32}(Debug)
 
 function show(io::IO, level::LogLevel)
     if     level == BelowMinLevel  print(io, "BelowMinLevel")
@@ -394,7 +396,7 @@ function logmsg_code(_module, file, line, level, message, exs...)
             level = $level
             # simplify std_level code emitted, if we know it is one of our global constants
             std_level = $(level isa Symbol ? :level : :(level isa $LogLevel ? level : convert($LogLevel, level)::$LogLevel))
-            if std_level >= $(_min_enabled_level)[]
+            if std_level.level >= $(_min_enabled_level)[]
                 group = $(log_data._group)
                 _module = $(log_data._module)
                 logger = $(current_logger_for_env)(std_level, group, _module)
@@ -541,7 +543,8 @@ with_logstate(f::Function, logstate) = @with(CURRENT_LOGSTATE => logstate, f())
 
 Disable all log messages at log levels equal to or less than `level`.  This is
 a *global* setting, intended to make debug logging extremely cheap when
-disabled.
+disabled. Note that this cannot be used to enable logging that is currently disabled
+by other mechanisms.
 
 # Examples
 ```julia
@@ -663,17 +666,21 @@ close(closed_stream)
 Simplistic logger for logging all messages with level greater than or equal to
 `min_level` to `stream`. If stream is closed then messages with log level
 greater or equal to `Warn` will be logged to `stderr` and below to `stdout`.
+
+This Logger is thread-safe, with a lock taken around orchestration of message
+limits i.e. `maxlog`, and writes to the stream.
 """
 struct SimpleLogger <: AbstractLogger
     stream::IO
+    lock::ReentrantLock
     min_level::LogLevel
     message_limits::Dict{Any,Int}
 end
-SimpleLogger(stream::IO, level=Info) = SimpleLogger(stream, level, Dict{Any,Int}())
+SimpleLogger(stream::IO, level=Info) = SimpleLogger(stream, ReentrantLock(), level, Dict{Any,Int}())
 SimpleLogger(level=Info) = SimpleLogger(closed_stream, level)
 
 shouldlog(logger::SimpleLogger, level, _module, group, id) =
-    get(logger.message_limits, id, 1) > 0
+    @lock logger.lock get(logger.message_limits, id, 1) > 0
 
 min_enabled_level(logger::SimpleLogger) = logger.min_level
 
@@ -684,15 +691,14 @@ function handle_message(logger::SimpleLogger, level::LogLevel, message, _module,
     @nospecialize
     maxlog = get(kwargs, :maxlog, nothing)
     if maxlog isa Core.BuiltinInts
-        remaining = get!(logger.message_limits, id, Int(maxlog)::Int)
-        logger.message_limits[id] = remaining - 1
-        remaining > 0 || return
+        @lock logger.lock begin
+            remaining = get!(logger.message_limits, id, Int(maxlog)::Int)
+            remaining == 0 && return
+            logger.message_limits[id] = remaining - 1
+        end
     end
     buf = IOBuffer()
     stream::IO = logger.stream
-    if !(isopen(stream)::Bool)
-        stream = stderr
-    end
     iob = IOContext(buf, stream)
     levelstr = level == Warn ? "Warning" : string(level)
     msglines = eachsplit(chomp(convert(String, string(message))::String), '\n')
@@ -706,7 +712,13 @@ function handle_message(logger::SimpleLogger, level::LogLevel, message, _module,
         println(iob, "│   ", key, " = ", val)
     end
     println(iob, "└ @ ", _module, " ", filepath, ":", line)
-    write(stream, take!(buf))
+    b = take!(buf)
+    @lock logger.lock begin
+        if !(isopen(stream)::Bool)
+            stream = stderr
+        end
+        write(stream, b)
+    end
     nothing
 end
 
diff --git a/stdlib/Logging/test/runtests.jl b/stdlib/Logging/test/runtests.jl
index 2fedbde557078..3e92b7d9e2697 100644
--- a/stdlib/Logging/test/runtests.jl
+++ b/stdlib/Logging/test/runtests.jl
@@ -306,4 +306,47 @@ end
     @test isempty(undoc)
 end
 
+@testset "Logging when multithreaded" begin
+    n = 10000
+    cmd = `$(Base.julia_cmd()) -t4 --color=no $(joinpath(@__DIR__, "threads_exec.jl")) $n`
+    fname = tempname()
+    @testset "Thread safety" begin
+        f = open(fname, "w")
+        @test success(run(pipeline(cmd, stderr=f)))
+        close(f)
+    end
+
+    @testset "No tearing in log printing" begin
+        # Check for print tearing by verifying that each log entry starts and ends correctly
+        f = open(fname, "r")
+        entry_start = r"┌ (Info|Warning|Error): iteration"
+        entry_end = r"└ "
+
+        open_entries = 0
+        total_entries = 0
+        for line in eachline(fname)
+            starts = count(entry_start, line)
+            starts > 1 && error("Interleaved logs: Multiple log entries started on one line")
+            if starts == 1
+                startswith(line, entry_start) || error("Interleaved logs: Log entry started in the middle of a line")
+                open_entries += 1
+                total_entries += 1
+            end
+
+            ends = count(entry_end, line)
+            starts == 1 && ends == 1 && error("Interleaved logs: Log entry started and and another ended on one line")
+            ends > 1 && error("Interleaved logs: Multiple log entries ended on one line")
+            if ends == 1
+                startswith(line, entry_end) || error("Interleaved logs: Log entry ended in the middle of a line")
+                open_entries -= 1
+            end
+            # Ensure no mismatched log entries
+            open_entries >= 0 || error("Interleaved logs")
+        end
+
+        @test open_entries == 0  # Ensure all entries closed properly
+        @test total_entries == n * 3  # Ensure all logs were printed (3 because @debug is hidden)
+    end
+end
+
 end
diff --git a/stdlib/Logging/test/threads_exec.jl b/stdlib/Logging/test/threads_exec.jl
new file mode 100644
index 0000000000000..497a22b1c7b22
--- /dev/null
+++ b/stdlib/Logging/test/threads_exec.jl
@@ -0,0 +1,13 @@
+using Logging
+
+function test_threads_exec(n)
+    Threads.@threads for i in 1:n
+        @debug "iteration" maxlog=1 _id=Symbol("$(i)_debug") i Threads.threadid()
+        @info "iteration" maxlog=1 _id=Symbol("$(i)_info") i Threads.threadid()
+        @warn "iteration" maxlog=1 _id=Symbol("$(i)_warn") i Threads.threadid()
+        @error "iteration" maxlog=1 _id=Symbol("$(i)_error") i Threads.threadid()
+    end
+end
+
+n = parse(Int, ARGS[1])
+test_threads_exec(n)
diff --git a/stdlib/Test/src/logging.jl b/stdlib/Test/src/logging.jl
index b224d79e47cd9..a3a94a642f250 100644
--- a/stdlib/Test/src/logging.jl
+++ b/stdlib/Test/src/logging.jl
@@ -107,8 +107,8 @@ function Logging.handle_message(logger::TestLogger, level, msg, _module,
         if maxlog isa Core.BuiltinInts
             @lock logger.lock begin
                 remaining = get!(logger.message_limits, id, Int(maxlog)::Int)
+                remaining == 0 && return
                 logger.message_limits[id] = remaining - 1
-                remaining > 0 || return
             end
         end
     end

From a7762c6816db5282e1ae19fd6ab3c74eb7ac53bf Mon Sep 17 00:00:00 2001
From: Sam Schweigel <33556084+xal-0@users.noreply.github.com>
Date: Fri, 4 Apr 2025 14:41:27 -0700
Subject: [PATCH 09/38] Add missing PARTITION_KIND_CONST_IMPORT case to
 print_partition (#58006)

(cherry picked from commit 75d5588d46bf7445626837f05e7a284ad85c7d30)
---
 base/show.jl | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/base/show.jl b/base/show.jl
index 48dff23a8af0a..3453c29956d59 100644
--- a/base/show.jl
+++ b/base/show.jl
@@ -3400,6 +3400,9 @@ function print_partition(io::IO, partition::Core.BindingPartition)
     elseif kind == PARTITION_KIND_CONST
         print(io, "constant binding to ")
         print(io, partition_restriction(partition))
+    elseif kind == PARTITION_KIND_CONST_IMPORT
+        print(io, "constant binding (declared with `import`) to ")
+        print(io, partition_restriction(partition))
     elseif kind == PARTITION_KIND_UNDEF_CONST
         print(io, "undefined const binding")
     elseif kind == PARTITION_KIND_GUARD

From 3582d8a50553e63e3004dbad57b3194d125aa805 Mon Sep 17 00:00:00 2001
From: Kristoffer Carlsson <kcarlsson89@gmail.com>
Date: Mon, 7 Apr 2025 14:06:54 +0200
Subject: [PATCH 10/38] Avoid most boxes in precompilation code (#57986)

- Use `local` where variable names accidentally overlapped and caused
boxes
- Use `@lock` to avoid closures
- Move out some recursive closures to top-level normal function to avoid
boxing them
- Use explicit boxes (`Ref`) instead of relying on the typeassert on the
`Core.Box` because it it hard to determine if a `Core.Box` is benign or
not.
- Only assign to `io` once to avoid boxing it.
- Type assert some `Tuple{Int, Int}` on `IO`.

The two remaining boxes after this is `t_print` and `monitor_std`.

(cherry picked from commit 4a3eba3b9125bfe825bf71f71404097f4f280176)
---
 base/precompilation.jl | 212 +++++++++++++++++++++--------------------
 1 file changed, 108 insertions(+), 104 deletions(-)

diff --git a/base/precompilation.jl b/base/precompilation.jl
index 3ab9fcad5aee6..c24026aa2a8ef 100644
--- a/base/precompilation.jl
+++ b/base/precompilation.jl
@@ -301,7 +301,7 @@ function show_progress(io::IO, p::MiniProgressBar; termwidth=nothing, carriagere
     else
         string(p.current, "/",  p.max)
     end
-    termwidth = @something termwidth displaysize(io)[2]
+    termwidth = @something termwidth (displaysize(io)::Tuple{Int,Int})[2]
     max_progress_width = max(0, min(termwidth - textwidth(p.header) - textwidth(progress_text) - 10 , p.width))
     n_filled = floor(Int, max_progress_width * perc / 100)
     partial_filled = (max_progress_width * perc / 100) - n_filled
@@ -409,6 +409,53 @@ function excluded_circular_deps_explanation(io::IOContext{IO}, ext_to_parent::Di
     return msg
 end
 
+
+function scan_pkg!(stack, could_be_cycle, cycles, pkg, dmap)
+    if haskey(could_be_cycle, pkg)
+        return could_be_cycle[pkg]
+    else
+        return scan_deps!(stack, could_be_cycle, cycles, pkg, dmap)
+    end
+end
+function scan_deps!(stack, could_be_cycle, cycles, pkg, dmap)
+    push!(stack, pkg)
+    cycle = nothing
+    for dep in dmap[pkg]
+        if dep in stack
+            # Created fresh cycle
+            cycle′ = stack[findlast(==(dep), stack):end]
+            if cycle === nothing || length(cycle′) < length(cycle)
+                cycle = cycle′ # try to report smallest cycle possible
+            end
+        elseif scan_pkg!(stack, could_be_cycle, cycles, dep, dmap)
+            # Reaches an existing cycle
+            could_be_cycle[pkg] = true
+            pop!(stack)
+            return true
+        end
+    end
+    pop!(stack)
+    if cycle !== nothing
+        push!(cycles, cycle)
+        could_be_cycle[pkg] = true
+        return true
+    end
+    could_be_cycle[pkg] = false
+    return false
+end
+
+# restrict to dependencies of given packages
+function collect_all_deps(direct_deps, dep, alldeps=Set{Base.PkgId}())
+    for _dep in direct_deps[dep]
+        if !(_dep in alldeps)
+            push!(alldeps, _dep)
+            collect_all_deps(direct_deps, _dep, alldeps)
+        end
+    end
+    return alldeps
+end
+
+
 function precompilepkgs(pkgs::Vector{String}=String[];
                         internal_call::Bool=false,
                         strict::Bool = false,
@@ -434,7 +481,7 @@ function _precompilepkgs(pkgs::Vector{String},
                          timing::Bool,
                          _from_loading::Bool,
                          configs::Vector{Config},
-                         io::IOContext{IO},
+                         _io::IOContext{IO},
                          fancyprint::Bool,
                          manifest::Bool,
                          ignore_loaded::Bool)
@@ -452,10 +499,9 @@ function _precompilepkgs(pkgs::Vector{String},
     num_tasks = parse(Int, get(ENV, "JULIA_NUM_PRECOMPILE_TASKS", string(default_num_tasks)))
     parallel_limiter = Base.Semaphore(num_tasks)
 
-    if _from_loading && !Sys.isinteractive() && Base.get_bool_env("JULIA_TESTS", false)
-        # suppress passive loading printing in julia test suite. `JULIA_TESTS` is set in Base.runtests
-        io = IOContext{IO}(devnull)
-    end
+    # suppress passive loading printing in julia test suite. `JULIA_TESTS` is set in Base.runtests
+    io = (_from_loading && !Sys.isinteractive() && Base.get_bool_env("JULIA_TESTS", false)) ? IOContext{IO}(devnull) : _io
+
 
     nconfigs = length(configs)
     hascolor = get(io, :color, false)::Bool
@@ -552,7 +598,7 @@ function _precompilepkgs(pkgs::Vector{String},
             end
         end
 
-        indirect_deps = Dict{Base.PkgId, Set{Base.PkgId}}()
+        local indirect_deps = Dict{Base.PkgId, Set{Base.PkgId}}()
         for package in keys(direct_deps)
             # Initialize a set to keep track of all dependencies for 'package'
             all_deps = Set{Base.PkgId}()
@@ -619,46 +665,14 @@ function _precompilepkgs(pkgs::Vector{String},
     could_be_cycle = Dict{Base.PkgId, Bool}()
     # temporary stack for the SCC-like algorithm below
     stack = Base.PkgId[]
-    function scan_pkg!(pkg, dmap)
-        if haskey(could_be_cycle, pkg)
-            return could_be_cycle[pkg]
-        else
-            return scan_deps!(pkg, dmap)
-        end
-    end
-    function scan_deps!(pkg, dmap)
-        push!(stack, pkg)
-        cycle = nothing
-        for dep in dmap[pkg]
-            if dep in stack
-                # Created fresh cycle
-                cycle′ = stack[findlast(==(dep), stack):end]
-                if cycle === nothing || length(cycle′) < length(cycle)
-                    cycle = cycle′ # try to report smallest cycle possible
-                end
-            elseif scan_pkg!(dep, dmap)
-                # Reaches an existing cycle
-                could_be_cycle[pkg] = true
-                pop!(stack)
-                return true
-            end
-        end
-        pop!(stack)
-        if cycle !== nothing
-            push!(cycles, cycle)
-            could_be_cycle[pkg] = true
-            return true
-        end
-        could_be_cycle[pkg] = false
-        return false
-    end
+
     # set of packages that depend on a cycle (either because they are
     # a part of a cycle themselves or because they transitively depend
     # on a package in some cycle)
     circular_deps = Base.PkgId[]
     for pkg in keys(direct_deps)
         @assert isempty(stack)
-        if scan_pkg!(pkg, direct_deps)
+        if scan_pkg!(stack, could_be_cycle, cycles, pkg, direct_deps)
             push!(circular_deps, pkg)
             for pkg_config in keys(was_processed)
                 # notify all to allow skipping
@@ -675,16 +689,6 @@ function _precompilepkgs(pkgs::Vector{String},
         if isempty(pkgs)
             pkgs = [pkg.name for pkg in project_deps]
         end
-        # restrict to dependencies of given packages
-        function collect_all_deps(direct_deps, dep, alldeps=Set{Base.PkgId}())
-            for _dep in direct_deps[dep]
-                if !(_dep in alldeps)
-                    push!(alldeps, _dep)
-                    collect_all_deps(direct_deps, _dep, alldeps)
-                end
-            end
-            return alldeps
-        end
         keep = Set{Base.PkgId}()
         for dep in direct_deps
             dep_pkgid = first(dep)
@@ -711,13 +715,13 @@ function _precompilepkgs(pkgs::Vector{String},
         end
     end
 
-    target = nothing
+    target = Ref{Union{Nothing, String}}(nothing)
     if nconfigs == 1
         if !isempty(only(configs)[1])
-            target = "for configuration $(join(only(configs)[1], " "))"
+            target[] = "for configuration $(join(only(configs)[1], " "))"
         end
     else
-        target = "for $nconfigs compilation configurations..."
+        target[] = "for $nconfigs compilation configurations..."
     end
     @debug "precompile: packages filtered"
 
@@ -727,7 +731,7 @@ function _precompilepkgs(pkgs::Vector{String},
 
     print_lock = io.io isa Base.LibuvStream ? io.io.lock::ReentrantLock : ReentrantLock()
     first_started = Base.Event()
-    printloop_should_exit::Bool = !fancyprint # exit print loop immediately if not fancy printing
+    printloop_should_exit = Ref{Bool}(!fancyprint) # exit print loop immediately if not fancy printing
     interrupted_or_done = Base.Event()
 
     ansi_moveup(n::Int) = string("\e[", n, "A")
@@ -736,19 +740,19 @@ function _precompilepkgs(pkgs::Vector{String},
     ansi_cleartoendofline = "\e[0K"
     ansi_enablecursor = "\e[?25h"
     ansi_disablecursor = "\e[?25l"
-    n_done::Int = 0
-    n_already_precomp::Int = 0
-    n_loaded::Int = 0
-    interrupted = false
+    n_done = Ref(0)
+    n_already_precomp = Ref(0)
+    n_loaded = Ref(0)
+    interrupted = Ref(false)
 
-    function handle_interrupt(err, in_printloop = false)
+    function handle_interrupt(err, in_printloop::Bool)
         notify(interrupted_or_done)
         in_printloop || wait(t_print) # wait to let the print loop cease first
         if err isa InterruptException
-            lock(print_lock) do
+            @lock print_lock begin
                 println(io, " Interrupted: Exiting precompilation...", ansi_cleartoendofline)
             end
-            interrupted = true
+            interrupted[] = true
             return true
         else
             return false
@@ -757,34 +761,34 @@ function _precompilepkgs(pkgs::Vector{String},
     std_outputs = Dict{PkgConfig,IOBuffer}()
     taskwaiting = Set{PkgConfig}()
     pkgspidlocked = Dict{PkgConfig,String}()
-    pkg_liveprinted = nothing
+    pkg_liveprinted = Ref{Union{Nothing, PkgId}}(nothing)
 
     function monitor_std(pkg_config, pipe; single_requested_pkg=false)
         pkg, config = pkg_config
         try
             liveprinting = false
             while !eof(pipe)
-                str = readline(pipe, keep=true)
+                local str = readline(pipe, keep=true)
                 if single_requested_pkg && (liveprinting || !isempty(str))
-                    lock(print_lock) do
+                    @lock print_lock begin
                         if !liveprinting
                             printpkgstyle(io, :Info, "Given $(pkg.name) was explicitly requested, output will be shown live $ansi_cleartoendofline",
                                 color = Base.info_color())
                             liveprinting = true
-                            pkg_liveprinted = pkg
+                            pkg_liveprinted[] = pkg
                         end
                         print(io, ansi_cleartoendofline, str)
                     end
                 end
                 write(get!(IOBuffer, std_outputs, pkg_config), str)
                 if !in(pkg_config, taskwaiting) && occursin("waiting for IO to finish", str)
-                    !fancyprint && lock(print_lock) do
+                    !fancyprint && @lock print_lock begin
                         println(io, pkg.name, color_string(" Waiting for background task / IO / timer.", Base.warn_color()))
                     end
                     push!(taskwaiting, pkg_config)
                 end
                 if !fancyprint && in(pkg_config, taskwaiting)
-                    lock(print_lock) do
+                    @lock print_lock begin
                         print(io, str)
                     end
                 end
@@ -799,9 +803,9 @@ function _precompilepkgs(pkgs::Vector{String},
         try
             wait(first_started)
             (isempty(pkg_queue) || interrupted_or_done.set) && return
-            lock(print_lock) do
-                if target !== nothing
-                    printpkgstyle(io, :Precompiling, target)
+            @lock print_lock begin
+                if target[] !== nothing
+                    printpkgstyle(io, :Precompiling, target[])
                 end
                 if fancyprint
                     print(io, ansi_disablecursor)
@@ -813,12 +817,12 @@ function _precompilepkgs(pkgs::Vector{String},
             last_length = 0
             bar = MiniProgressBar(; indent=0, header = "Precompiling packages ", color = :green, percentage=false, always_reprint=true)
             n_total = length(direct_deps) * length(configs)
-            bar.max = n_total - n_already_precomp
+            bar.max = n_total - n_already_precomp[]
             final_loop = false
             n_print_rows = 0
-            while !printloop_should_exit
-                lock(print_lock) do
-                    term_size = displaysize(io)
+            while !printloop_should_exit[]
+                @lock print_lock begin
+                    term_size = displaysize(io)::Tuple{Int, Int}
                     num_deps_show = max(term_size[1] - 3, 2) # show at least 2 deps
                     pkg_queue_show = if !interrupted_or_done.set && length(pkg_queue) > num_deps_show
                         last(pkg_queue, num_deps_show)
@@ -829,11 +833,11 @@ function _precompilepkgs(pkgs::Vector{String},
                         if i > 1
                             print(iostr, ansi_cleartoend)
                         end
-                        bar.current = n_done - n_already_precomp
-                        bar.max = n_total - n_already_precomp
+                        bar.current = n_done[] - n_already_precomp[]
+                        bar.max = n_total - n_already_precomp[]
                         # when sizing to the terminal width subtract a little to give some tolerance to resizing the
                         # window between print cycles
-                        termwidth = displaysize(io)[2] - 4
+                        termwidth = (displaysize(io)::Tuple{Int,Int})[2] - 4
                         if !final_loop
                             s = sprint(io -> show_progress(io, bar; termwidth, carriagereturn=false); context=io)
                             print(iostr, Base._truncate_at_width_or_chars(true, s, termwidth), "\n")
@@ -877,10 +881,10 @@ function _precompilepkgs(pkgs::Vector{String},
                     last_length = length(pkg_queue_show)
                     n_print_rows = count("\n", str_)
                     print(io, str_)
-                    printloop_should_exit = interrupted_or_done.set && final_loop
+                    printloop_should_exit[] = interrupted_or_done.set && final_loop
                     final_loop = interrupted_or_done.set # ensures one more loop to tidy last task after finish
                     i += 1
-                    printloop_should_exit || print(io, ansi_moveup(n_print_rows), ansi_movecol1)
+                    printloop_should_exit[] || print(io, ansi_moveup(n_print_rows), ansi_movecol1)
                 end
                 wait(t)
             end
@@ -931,9 +935,9 @@ function _precompilepkgs(pkgs::Vector{String},
                         t_monitor = @async monitor_std(pkg_config, std_pipe; single_requested_pkg)
 
                         name = describe_pkg(pkg, is_project_dep, flags, cacheflags)
-                        lock(print_lock) do
+                        @lock print_lock begin
                             if !fancyprint && isempty(pkg_queue)
-                                printpkgstyle(io, :Precompiling, something(target, "packages..."))
+                                printpkgstyle(io, :Precompiling, something(target[], "packages..."))
                             end
                         end
                         push!(pkg_queue, pkg_config)
@@ -960,16 +964,16 @@ function _precompilepkgs(pkgs::Vector{String},
                             end
                             if ret isa Base.PrecompilableError
                                 push!(precomperr_deps, pkg_config)
-                                !fancyprint && lock(print_lock) do
+                                !fancyprint && @lock print_lock begin
                                     println(io, _timing_string(t), color_string("  ? ", Base.warn_color()), name)
                                 end
                             else
-                                !fancyprint && lock(print_lock) do
+                                !fancyprint && @lock print_lock begin
                                     println(io, _timing_string(t), color_string("  ✓ ", loaded ? Base.warn_color() : :green), name)
                                 end
                                 was_recompiled[pkg_config] = true
                             end
-                            loaded && (n_loaded += 1)
+                            loaded && (n_loaded[] += 1)
                         catch err
                             # @show err
                             close(std_pipe.in) # close pipe to end the std output monitor
@@ -978,7 +982,7 @@ function _precompilepkgs(pkgs::Vector{String},
                                 errmsg = String(take!(get(IOBuffer, std_outputs, pkg_config)))
                                 delete!(std_outputs, pkg_config) # so it's not shown as warnings, given error report
                                 failed_deps[pkg_config] = (strict || is_project_dep) ? string(sprint(showerror, err), "\n", strip(errmsg)) : ""
-                                !fancyprint && lock(print_lock) do
+                                !fancyprint && @lock print_lock begin
                                     println(io, " "^9, color_string("  ✗ ", Base.error_color()), name)
                                 end
                             else
@@ -990,15 +994,15 @@ function _precompilepkgs(pkgs::Vector{String},
                             Base.release(parallel_limiter)
                         end
                     else
-                        is_stale || (n_already_precomp += 1)
+                        is_stale || (n_already_precomp[] += 1)
                     end
-                    n_done += 1
+                    n_done[] += 1
                     notify(was_processed[pkg_config])
                 catch err_outer
                     # For debugging:
                     # println("Task failed $err_outer")
                     # Base.display_error(ErrorException(""), Base.catch_backtrace())# logging doesn't show here
-                    handle_interrupt(err_outer) || rethrow()
+                    handle_interrupt(err_outer, false) || rethrow()
                     notify(was_processed[pkg_config])
                 finally
                     filter!(!istaskdone, tasks)
@@ -1013,13 +1017,13 @@ function _precompilepkgs(pkgs::Vector{String},
     try
         wait(interrupted_or_done)
     catch err
-        handle_interrupt(err) || rethrow()
+        handle_interrupt(err, false) || rethrow()
     finally
         Base.LOADING_CACHE[] = nothing
     end
     notify(first_started) # in cases of no-op or !fancyprint
     fancyprint && wait(t_print)
-    quick_exit = !all(istaskdone, tasks) || interrupted # if some not finished internal error is likely
+    quick_exit = !all(istaskdone, tasks) || interrupted[] # if some not finished internal error is likely
     seconds_elapsed = round(Int, (time_ns() - time_start) / 1e9)
     ndeps = count(values(was_recompiled))
     if ndeps > 0 || !isempty(failed_deps) || (quick_exit && !isempty(std_outputs))
@@ -1031,18 +1035,18 @@ function _precompilepkgs(pkgs::Vector{String},
                 end
                 plural = length(configs) > 1 ? "dependency configurations" : ndeps == 1 ? "dependency" : "dependencies"
                 print(iostr, "  $(ndeps) $(plural) successfully precompiled in $(seconds_elapsed) seconds")
-                if n_already_precomp > 0 || !isempty(circular_deps)
-                    n_already_precomp > 0 && (print(iostr, ". $n_already_precomp already precompiled"))
+                if n_already_precomp[] > 0 || !isempty(circular_deps)
+                    n_already_precomp[] > 0 && (print(iostr, ". $(n_already_precomp[]) already precompiled"))
                     !isempty(circular_deps) && (print(iostr, ". $(length(circular_deps)) skipped due to circular dependency"))
                     print(iostr, ".")
                 end
-                if n_loaded > 0
-                    plural1 = length(configs) > 1 ? "dependency configurations" : n_loaded == 1 ? "dependency" : "dependencies"
-                    plural2 = n_loaded == 1 ? "a different version is" : "different versions are"
-                    plural3 = n_loaded == 1 ? "" : "s"
-                    plural4 = n_loaded == 1 ? "this package" : "these packages"
+                if n_loaded[] > 0
+                    local plural1 = length(configs) > 1 ? "dependency configurations" : n_loaded[] == 1 ? "dependency" : "dependencies"
+                    local plural2 = n_loaded[] == 1 ? "a different version is" : "different versions are"
+                    local plural3 = n_loaded[] == 1 ? "" : "s"
+                    local plural4 = n_loaded[] == 1 ? "this package" : "these packages"
                     print(iostr, "\n  ",
-                        color_string(string(n_loaded), Base.warn_color()),
+                        color_string(string(n_loaded[]), Base.warn_color()),
                         " $(plural1) precompiled but ",
                         color_string("$(plural2) currently loaded", Base.warn_color()),
                         ". Restart julia to access the new version$(plural3). \
@@ -1062,12 +1066,12 @@ function _precompilepkgs(pkgs::Vector{String},
             let std_outputs = Tuple{PkgConfig,SubString{String}}[(pkg_config, strip(String(take!(io)))) for (pkg_config,io) in std_outputs]
                 filter!(kv -> !isempty(last(kv)), std_outputs)
                 if !isempty(std_outputs)
-                    plural1 = length(std_outputs) == 1 ? "y" : "ies"
-                    plural2 = length(std_outputs) == 1 ? "" : "s"
+                    local plural1 = length(std_outputs) == 1 ? "y" : "ies"
+                    local plural2 = length(std_outputs) == 1 ? "" : "s"
                     print(iostr, "\n  ", color_string("$(length(std_outputs))", Base.warn_color()), " dependenc$(plural1) had output during precompilation:")
                     for (pkg_config, err) in std_outputs
                         pkg, config = pkg_config
-                        err = if pkg == pkg_liveprinted
+                        err = if pkg == pkg_liveprinted[]
                             "[Output was shown above]"
                         else
                             join(split(err, "\n"), color_string("\n│  ", Base.warn_color()))
@@ -1079,7 +1083,7 @@ function _precompilepkgs(pkgs::Vector{String},
             end
         end
         let str=str
-            lock(print_lock) do
+            @lock print_lock begin
                 println(io, str)
             end
         end
@@ -1157,7 +1161,7 @@ function precompile_pkgs_maybe_cachefile_lock(f, io::IO, print_lock::ReentrantLo
         else
             "another machine (hostname: $hostname, pid: $pid, pidfile: $pidfile)"
         end
-        !fancyprint && lock(print_lock) do
+        !fancyprint && @lock print_lock begin
             println(io, "    ", pkg.name, _color_string(" Being precompiled by $(pkgspidlocked[pkg_config])", Base.info_color(), hascolor))
         end
         Base.release(parallel_limiter) # release so other work can be done while waiting

From 4f6fbd6870fbec0b033a038e0763086c1da9eb58 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Wed, 9 Apr 2025 08:36:18 -0400
Subject: [PATCH 11/38] inference: simplify `abstract_eval_globalref` (#58026)

By moving the optional `assume_bindings_static` refinement logic into
`abstract_eval_partition_load` and removing the redirect via
`abstract_eval_globalref_partition`.
Also adds test cases with `assume_bindings_static=true`.
---
 Compiler/src/abstractinterpretation.jl | 46 ++++++++++++--------------
 Compiler/test/inference.jl             | 22 +++++++++---
 base/invalidation.jl                   |  6 ++--
 3 files changed, 42 insertions(+), 32 deletions(-)

diff --git a/Compiler/src/abstractinterpretation.jl b/Compiler/src/abstractinterpretation.jl
index ee95c105691d9..94d5b11a18ca5 100644
--- a/Compiler/src/abstractinterpretation.jl
+++ b/Compiler/src/abstractinterpretation.jl
@@ -2570,9 +2570,9 @@ function abstract_eval_replaceglobal!(interp::AbstractInterpreter, sv::AbsIntSta
             M isa Module || return CallMeta(Union{}, TypeError, EFFECTS_THROWS, NoCallInfo())
             s isa Symbol || return CallMeta(Union{}, TypeError, EFFECTS_THROWS, NoCallInfo())
             gr = GlobalRef(M, s)
-            (valid_worlds, (rte, T)) = scan_leaf_partitions(interp, gr, sv.world) do interp, _, partition
+            (valid_worlds, (rte, T)) = scan_leaf_partitions(interp, gr, sv.world) do interp, binding, partition
                 partition_T = nothing
-                partition_rte = abstract_eval_partition_load(interp, partition)
+                partition_rte = abstract_eval_partition_load(interp, binding, partition)
                 if binding_kind(partition) == PARTITION_KIND_GLOBAL
                     partition_T = partition_restriction(partition)
                 end
@@ -3511,13 +3511,11 @@ function abstract_eval_binding_partition!(interp::AbstractInterpreter, g::Global
     return partition
 end
 
-abstract_eval_partition_load(interp::Union{AbstractInterpreter, Nothing}, ::Core.Binding, partition::Core.BindingPartition) =
-    abstract_eval_partition_load(interp, partition)
-function abstract_eval_partition_load(interp::Union{AbstractInterpreter, Nothing}, partition::Core.BindingPartition)
+function abstract_eval_partition_load(interp::Union{AbstractInterpreter, Nothing}, binding::Core.Binding, partition::Core.BindingPartition)
     kind = binding_kind(partition)
     isdepwarn = (partition.kind & PARTITION_FLAG_DEPWARN) != 0
     local_getglobal_effects = Effects(generic_getglobal_effects, effect_free=isdepwarn ? ALWAYS_FALSE : ALWAYS_TRUE)
-    if is_some_guard(kind) || kind == PARTITION_KIND_UNDEF_CONST
+    if is_some_guard(kind)
         if interp !== nothing && InferenceParams(interp).assume_bindings_static
             return RTEffects(Union{}, UndefVarError, EFFECTS_THROWS)
         else
@@ -3543,12 +3541,23 @@ function abstract_eval_partition_load(interp::Union{AbstractInterpreter, Nothing
         # Could be replaced by a backdated const which has an effect, so we can't assume it won't.
         # Besides, we would prefer not to merge the world range for this into the world range for
         # _GLOBAL, because that would pessimize codegen.
-        local_getglobal_effects = Effects(local_getglobal_effects, effect_free=ALWAYS_FALSE)
+        effects = Effects(local_getglobal_effects, effect_free=ALWAYS_FALSE)
         rt = Any
     else
         rt = partition_restriction(partition)
+        effects = local_getglobal_effects
+    end
+    if (interp !== nothing && InferenceParams(interp).assume_bindings_static &&
+        kind in (PARTITION_KIND_GLOBAL, PARTITION_KIND_DECLARED) &&
+        isdefined(binding, :value))
+        exct = Union{}
+        effects = Effects(generic_getglobal_effects; nothrow=true)
+    else
+        # We do not assume in general that assigned global bindings remain assigned.
+        # The existence of pkgimages allows them to revert in practice.
+        exct = UndefVarError
     end
-    return RTEffects(rt, UndefVarError, local_getglobal_effects)
+    return RTEffects(rt, exct, effects)
 end
 
 function scan_specified_partitions(query::Function, walk_binding_partition::Function, interp, g::GlobalRef, wwr::WorldWithRange)
@@ -3596,28 +3605,15 @@ scan_partitions(query::Function, interp, g::GlobalRef, wwr::WorldWithRange) =
 abstract_load_all_consistent_leaf_partitions(interp, g::GlobalRef, wwr::WorldWithRange) =
     scan_leaf_partitions(abstract_eval_partition_load, interp, g, wwr)
 
-function abstract_eval_globalref_partition(interp, binding::Core.Binding, partition::Core.BindingPartition)
-    # For inference purposes, we don't particularly care which global binding we end up loading, we only
-    # care about its type. However, we would still like to terminate the world range for the particular
-    # binding we end up reaching such that codegen can emit a simpler pointer load.
-    Pair{RTEffects, Union{Nothing, Core.Binding}}(
-        abstract_eval_partition_load(interp, partition),
-        binding_kind(partition) in (PARTITION_KIND_GLOBAL, PARTITION_KIND_DECLARED) ? binding : nothing)
-end
-
 function abstract_eval_globalref(interp, g::GlobalRef, saw_latestworld::Bool, sv::AbsIntState)
     if saw_latestworld
         return RTEffects(Any, Any, generic_getglobal_effects)
     end
-    (valid_worlds, (ret, binding_if_global)) = scan_leaf_partitions(abstract_eval_globalref_partition, interp, g, sv.world)
+    # For inference purposes, we don't particularly care which global binding we end up loading, we only
+    # care about its type. However, we would still like to terminate the world range for the particular
+    # binding we end up reaching such that codegen can emit a simpler pointer load.
+    (valid_worlds, ret) = scan_leaf_partitions(abstract_eval_partition_load, interp, g, sv.world)
     update_valid_age!(sv, valid_worlds)
-    if ret.rt !== Union{} && ret.exct === UndefVarError && binding_if_global !== nothing && InferenceParams(interp).assume_bindings_static
-        if isdefined(binding_if_global, :value)
-            ret = RTEffects(ret.rt, Union{}, Effects(generic_getglobal_effects, nothrow=true))
-        end
-        # We do not assume in general that assigned global bindings remain assigned.
-        # The existence of pkgimages allows them to revert in practice.
-    end
     return ret
 end
 
diff --git a/Compiler/test/inference.jl b/Compiler/test/inference.jl
index ec569a0ba04b5..57b2b50053579 100644
--- a/Compiler/test/inference.jl
+++ b/Compiler/test/inference.jl
@@ -6160,14 +6160,28 @@ end === Int
     swapglobal!(@__MODULE__, :swapglobal!_xxx, x)
 end === Union{}
 
+@newinterp AssumeBindingsStaticInterp
+Compiler.InferenceParams(::AssumeBindingsStaticInterp) = Compiler.InferenceParams(; assume_bindings_static=true)
+
 eval(Expr(:const, :swapglobal!_must_throw))
-@newinterp SwapGlobalInterp
-Compiler.InferenceParams(::SwapGlobalInterp) = Compiler.InferenceParams(; assume_bindings_static=true)
 function func_swapglobal!_must_throw(x)
     swapglobal!(@__MODULE__, :swapglobal!_must_throw, x)
 end
-@test Base.infer_return_type(func_swapglobal!_must_throw, (Int,); interp=SwapGlobalInterp()) === Union{}
-@test !Compiler.is_effect_free(Base.infer_effects(func_swapglobal!_must_throw, (Int,); interp=SwapGlobalInterp()) )
+@test Base.infer_return_type(func_swapglobal!_must_throw, (Int,); interp=AssumeBindingsStaticInterp()) === Union{}
+@test !Compiler.is_effect_free(Base.infer_effects(func_swapglobal!_must_throw, (Int,); interp=AssumeBindingsStaticInterp()) )
+
+global global_decl_defined
+global_decl_defined = 42
+@test Base.infer_effects(; interp=AssumeBindingsStaticInterp()) do
+    global global_decl_defined
+    return global_decl_defined
+end |> Compiler.is_nothrow
+global global_decl_defined2::Int
+global_decl_defined2 = 42
+@test Base.infer_effects(; interp=AssumeBindingsStaticInterp()) do
+    global global_decl_defined2
+    return global_decl_defined2
+end |> Compiler.is_nothrow
 
 @eval get_exception() = $(Expr(:the_exception))
 @test Base.infer_return_type() do
diff --git a/base/invalidation.jl b/base/invalidation.jl
index 14b88e71b9def..e974bcd226de8 100644
--- a/base/invalidation.jl
+++ b/base/invalidation.jl
@@ -124,12 +124,12 @@ function invalidate_code_for_globalref!(b::Core.Binding, invalidated_bpart::Core
     (_, (ib, ibpart)) = Compiler.walk_binding_partition(b, invalidated_bpart, new_max_world)
     (_, (nb, nbpart)) = Compiler.walk_binding_partition(b, new_bpart, new_max_world+1)
 
-    # abstract_eval_globalref_partition is the maximum amount of information that inference
+    # `abstract_eval_partition_load` is the maximum amount of information that inference
     # reads from a binding partition. If this information does not change - we do not need to
     # invalidate any code that inference created, because we know that the result will not change.
     need_to_invalidate_code =
-        Compiler.abstract_eval_globalref_partition(nothing, ib, ibpart) !==
-        Compiler.abstract_eval_globalref_partition(nothing, nb, nbpart)
+        Compiler.abstract_eval_partition_load(nothing, ib, ibpart) !==
+        Compiler.abstract_eval_partition_load(nothing, nb, nbpart)
 
     need_to_invalidate_export = export_affecting_partition_flags(invalidated_bpart) !==
                                 export_affecting_partition_flags(new_bpart)

From f9f5f6e3fbac258857cd22fc98823adf3710be69 Mon Sep 17 00:00:00 2001
From: N5N3 <2642243996@qq.com>
Date: Sun, 6 Apr 2025 12:36:26 +0800
Subject: [PATCH 12/38] typeintersect: fix triangular vars handling outside
 constructor (#58018)

also add more fast path.
---
 src/subtype.c   | 15 +++++++--------
 test/subtype.jl | 15 +++++++++++++--
 2 files changed, 20 insertions(+), 10 deletions(-)

diff --git a/src/subtype.c b/src/subtype.c
index 1086d11d2fe8c..c1c811d4e0ad5 100644
--- a/src/subtype.c
+++ b/src/subtype.c
@@ -1393,7 +1393,7 @@ static int subtype(jl_value_t *x, jl_value_t *y, jl_stenv_t *e, int param)
         x = pick_union_element(x, e, 0);
     }
     if (jl_is_uniontype(y)) {
-        if (x == ((jl_uniontype_t*)y)->a || x == ((jl_uniontype_t*)y)->b)
+        if (obviously_in_union(y, x))
             return 1;
         if (jl_is_unionall(x))
             return subtype_unionall(y, (jl_unionall_t*)x, e, 0, param);
@@ -2539,9 +2539,6 @@ static jl_value_t *intersect_aside(jl_value_t *x, jl_value_t *y, jl_stenv_t *e,
 
 static jl_value_t *intersect_union(jl_value_t *x, jl_uniontype_t *u, jl_stenv_t *e, int8_t R, int param)
 {
-    // band-aid for #56040
-    if (!jl_is_uniontype(x) && obviously_in_union((jl_value_t *)u, x))
-        return x;
     int no_free = !jl_has_free_typevars(x) && !jl_has_free_typevars((jl_value_t*)u);
     if (param == 2 || no_free) {
         jl_value_t *a=NULL, *b=NULL;
@@ -2678,7 +2675,7 @@ static void set_bound(jl_value_t **bound, jl_value_t *val, jl_tvar_t *v, jl_sten
 // subtype, treating all vars as existential
 static int subtype_in_env_existential(jl_value_t *x, jl_value_t *y, jl_stenv_t *e)
 {
-    if (x == jl_bottom_type || y == (jl_value_t*)jl_any_type)
+    if (x == jl_bottom_type || y == (jl_value_t*)jl_any_type || obviously_in_union(y, x))
         return 1;
     int8_t *rs = (int8_t*)alloca(current_env_length(e));
     jl_varbinding_t *v = e->vars;
@@ -2801,7 +2798,7 @@ static jl_value_t *intersect_var(jl_tvar_t *b, jl_value_t *a, jl_stenv_t *e, int
     jl_value_t *ub = R ? intersect_aside(a, bb->ub, e, bb->depth0) : intersect_aside(bb->ub, a, e, bb->depth0);
     if (ub == jl_bottom_type)
         return jl_bottom_type;
-    if (bb->constraintkind == 1 || e->triangular) {
+    if (bb->constraintkind == 1 || (e->triangular && param == 1)) {
         if (e->triangular && check_unsat_bound(ub, b, e))
             return jl_bottom_type;
         set_bound(&bb->ub, ub, b, e);
@@ -4116,12 +4113,14 @@ static jl_value_t *intersect(jl_value_t *x, jl_value_t *y, jl_stenv_t *e, int pa
         if (jl_subtype(y, x)) return y;
     }
     if (jl_is_uniontype(x)) {
-        if (y == ((jl_uniontype_t*)x)->a || y == ((jl_uniontype_t*)x)->b)
+        if (obviously_in_union(x, y))
             return y;
+        if (jl_is_uniontype(y) && obviously_in_union(y, x))
+            return x;
         return intersect_union(y, (jl_uniontype_t*)x, e, 0, param);
     }
     if (jl_is_uniontype(y)) {
-        if (x == ((jl_uniontype_t*)y)->a || x == ((jl_uniontype_t*)y)->b)
+        if (obviously_in_union(y, x))
             return x;
         if (jl_is_unionall(x) && (jl_has_free_typevars(x) || jl_has_free_typevars(y)))
             return intersect_unionall(y, (jl_unionall_t*)x, e, 0, param);
diff --git a/test/subtype.jl b/test/subtype.jl
index 979746bd626dc..d186262a6e1ba 100644
--- a/test/subtype.jl
+++ b/test/subtype.jl
@@ -2087,8 +2087,7 @@ let A = Tuple{Any, Type{Ref{_A}} where _A},
     I = typeintersect(A, B)
     @test I != Union{}
     @test Tuple{Type{Ref{Integer}}, Type{Ref{Integer}}} <: I
-    # TODO: this intersection result seems too wide (I == B) ?
-    @test_broken !<:(Tuple{Type{Int}, Type{Int}}, I)
+    @test !<:(Tuple{Type{Int}, Type{Int}}, I)
 end
 
 @testintersect(Tuple{Type{T}, T} where T<:(Tuple{Vararg{_A, _B}} where _B where _A),
@@ -2757,3 +2756,15 @@ end
     Pair{N, T} where {N,NTuple{N,Int}<:T<:Tuple{Int,Vararg{Int}}},
     !Union{}
 )
+
+#issue 57852
+@testintersect(
+    Tuple{Type{T}, Type{<:F}, Type{<:F}} where {T, F<:Union{String, T}},
+    Tuple{Type{Complex{T}} where T, Type{Complex{T}} where T, Type{String}},
+    Tuple{Type{Complex{T}}, Type{Complex{T}}, Type{String}} where T
+)
+@testintersect(
+    Tuple{Type{T}, Type{<:Union{F, Nothing}}, Type{<:Union{F, Nothing}}} where {T, F<:Union{String, T}},
+    Tuple{Type{Complex{T}} where T, Type{Complex{T}} where T, Type{String}},
+    Tuple{Type{Complex{T}}, Type{Complex{T}}, Type{String}} where T
+)

From fe36e653b61b734ec4b66f10be70482e9f7f4c87 Mon Sep 17 00:00:00 2001
From: Chengyu Han <git@wo-class.cn>
Date: Thu, 10 Apr 2025 18:08:37 +0800
Subject: [PATCH 13/38] deps: Update MPFR to v4.2.2 (#58039)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

GNU MPFR version 4.2.2 was released on 20 March 2025.

Fix #57945

---------

Co-authored-by: Mosè Giordano <765740+giordano@users.noreply.github.com>
(cherry picked from commit 9d4e31f7eb9441f1d78f07d9fb181dbac59ce7a8)
---
 deps/checksums/mpfr              | 76 ++++++++++++++++----------------
 deps/mpfr.version                |  3 +-
 stdlib/MPFR_jll/Project.toml     |  2 +-
 stdlib/MPFR_jll/test/runtests.jl |  2 +-
 stdlib/Manifest.toml             |  2 +-
 5 files changed, 43 insertions(+), 42 deletions(-)

diff --git a/deps/checksums/mpfr b/deps/checksums/mpfr
index 7b3b57978bd01..7f0de6099713c 100644
--- a/deps/checksums/mpfr
+++ b/deps/checksums/mpfr
@@ -1,38 +1,38 @@
-MPFR.v4.2.1+2.aarch64-apple-darwin.tar.gz/md5/1f5bba3e8e540720e239da75e5ae79eb
-MPFR.v4.2.1+2.aarch64-apple-darwin.tar.gz/sha512/7de26c625e540a5b88e280ec2cb8712d4514732d80a0c6342d2b2cabc6bc17c05f6c614b8e38800c93a4af5438c554733d3fa2002ef70072dfb44c08d3f03d26
-MPFR.v4.2.1+2.aarch64-linux-gnu.tar.gz/md5/112ddd4e5cddf36b005394f9cd81b8e5
-MPFR.v4.2.1+2.aarch64-linux-gnu.tar.gz/sha512/dc125f625e8c74ce18c052ef759ccbcfc2f3a932f2810a306bdddf70d5f37f3546200690fd08fb76742022322a7c1b9aa907b4aec6edb318060f0648ff426cbc
-MPFR.v4.2.1+2.aarch64-linux-musl.tar.gz/md5/a0919ef7cc35bb663d05e27da2bcb9a7
-MPFR.v4.2.1+2.aarch64-linux-musl.tar.gz/sha512/8acbaaca766c2ce225ac8df88c103a57fc52119d1fd54e9fc7d1f9d725c4ca9f74a0090e86eea0c140482a1abaf5b6086c453824a7516e9aef3ede5058f1767c
-MPFR.v4.2.1+2.aarch64-unknown-freebsd.tar.gz/md5/61e1dcc7e323b976854a4e8164316d37
-MPFR.v4.2.1+2.aarch64-unknown-freebsd.tar.gz/sha512/f3a5493f88b290d15aff9bf79b15158d19bea05af7210b2967368e0b2f98cd291f77e62f39ee0c7ad4e9d2ef6ebdba4bf2fea24c723791f71f7b9b1ef989a67d
-MPFR.v4.2.1+2.armv6l-linux-gnueabihf.tar.gz/md5/629aad4ac45ba23becd8a26df188638c
-MPFR.v4.2.1+2.armv6l-linux-gnueabihf.tar.gz/sha512/bb05a8bf127eb16608a82037546f48462cb6168e1adcdb2c60dc3bd08f62cff30cf603abcab87bb336305d37dbb7b0480ea8f6664191879bdcd487738a33dd99
-MPFR.v4.2.1+2.armv6l-linux-musleabihf.tar.gz/md5/0c3c026051b096d98c8d476dd44db334
-MPFR.v4.2.1+2.armv6l-linux-musleabihf.tar.gz/sha512/9e791fe9748c87068c167517883cc905fe51ea38d2db89562a7a0959cfd83b268eed2897e5eaaf90c0b0b08a4efd8039bdeece64e83b17bf1d676570d13c2b98
-MPFR.v4.2.1+2.armv7l-linux-gnueabihf.tar.gz/md5/a2433a717e49ad95c3e430a538d01134
-MPFR.v4.2.1+2.armv7l-linux-gnueabihf.tar.gz/sha512/abde21a943d4af312e0d44b1ff1d4aefa10b2f38c74ff0e04c0c2b8561750ef5d164679564ffe1b551821d83ebcafbe99467230b37fe4591c593a24dfb070c6a
-MPFR.v4.2.1+2.armv7l-linux-musleabihf.tar.gz/md5/4c892b4cbf1926d5d2b6a88330015c8f
-MPFR.v4.2.1+2.armv7l-linux-musleabihf.tar.gz/sha512/24825bb1268ef2ea42894ec9ff6589308abae430dd8e43a2ca0d368f1e718fd3cdf6d9bc4bc383346970ba845d2ef1721c4848ee0c783d09addc5505131db3e6
-MPFR.v4.2.1+2.i686-linux-gnu.tar.gz/md5/0b1e0268dcaeb3aa0f7f0a6451c6b841
-MPFR.v4.2.1+2.i686-linux-gnu.tar.gz/sha512/f0ef142c7b86e8f92b78a7ff0607da70bf8f3970b118fa77438cbb0acbea604dc0c7566b52ff1f85b179aac7661b31e4aee049f2c5ff799c95b385ba9cde2a25
-MPFR.v4.2.1+2.i686-linux-musl.tar.gz/md5/2fc9a938e76e7bdc0b73d7e8bfc8b8ee
-MPFR.v4.2.1+2.i686-linux-musl.tar.gz/sha512/4aed3884ad569b7695b9383db9d9dbb279ffe5349f7757b867ff860fa600b47faa4c169f4a60409666ce45fc6e6f269c18cef2df6fa0585f056d7e07e55005b8
-MPFR.v4.2.1+2.i686-w64-mingw32.tar.gz/md5/d13c44bb28d721107639c8555db5e157
-MPFR.v4.2.1+2.i686-w64-mingw32.tar.gz/sha512/1b5562d2df322c28bd06bb4ba8c9039cf90ed62affcf7f2b0d7ae8925d503c76a0d3d2f9b65c8c55575f245a4df8fbc4c7c63e93e7b973188f203a7fbda4eac5
-MPFR.v4.2.1+2.powerpc64le-linux-gnu.tar.gz/md5/52b3912b2c5f59ab3dcd7c3e06ca41b5
-MPFR.v4.2.1+2.powerpc64le-linux-gnu.tar.gz/sha512/533cf1f93c4464b4bed1d56ea79946fc2d20f3a7825d6b0383ed98cec99f85713e7bca549fd8948adb69aedc14e5d14a54238b3e67ef103e1b049b0cfb6cc1c9
-MPFR.v4.2.1+2.riscv64-linux-gnu.tar.gz/md5/aef7709c8457ee2db2622c39f1da16b7
-MPFR.v4.2.1+2.riscv64-linux-gnu.tar.gz/sha512/7a9c88563e3e7ab22a3aaa45690ed89c3e7eb22333a3d45c5e04ad2660c91ad2c97f10cd6c1aa1ccfdbf97186f9fd7f92330a41ec0be026e2ff84c5ba91f2652
-MPFR.v4.2.1+2.x86_64-apple-darwin.tar.gz/md5/12afc9778e39a5b6d9ea0161e2c80a95
-MPFR.v4.2.1+2.x86_64-apple-darwin.tar.gz/sha512/a9070423a898fa865740753ae7513d3cc0b500bd9b6b5c6aa672833dcac429efd806eff48501b51afcba5db0d31e79dac243b11b2f8847a1551576c6131506f5
-MPFR.v4.2.1+2.x86_64-linux-gnu.tar.gz/md5/46c6a5f40243795bdff51bd68a89c82e
-MPFR.v4.2.1+2.x86_64-linux-gnu.tar.gz/sha512/df8209d69ae55dd54491055078f113f4ac8be7bc68e1c0eb62944e6c9c04ed3e9a55c4a5f28ec68eb69f558d9f4d1b975f36de572fbd0ef7720568efc8042327
-MPFR.v4.2.1+2.x86_64-linux-musl.tar.gz/md5/045236ee0d558d2eda42df76c3397f69
-MPFR.v4.2.1+2.x86_64-linux-musl.tar.gz/sha512/52b68a673160af7cd09b191f3c28e17d5af7516b5baa86c0df9cb63a116772a15b5358f3db5f0b254b5752c652f8959454667cc1726ea4ff30946e3bbdb90ab4
-MPFR.v4.2.1+2.x86_64-unknown-freebsd.tar.gz/md5/da3da71bc7572eca5bc3d3895abf73c2
-MPFR.v4.2.1+2.x86_64-unknown-freebsd.tar.gz/sha512/4270b83ebe72d431f8fd9127b2b8d3bd75c2e52c563d390a4ca8d40c0514f5996fce57746d07b7d3bcbf93bfe78d420f815fde5eda4d84a5bcb7b7cf0e092504
-MPFR.v4.2.1+2.x86_64-w64-mingw32.tar.gz/md5/2a6f5ccb8d45591a845ad43916beb85a
-MPFR.v4.2.1+2.x86_64-w64-mingw32.tar.gz/sha512/db9ecc9d8247fe4421c4cc9c6ab540e17a7445056b7a1062d4e334b353783a1c067062fd8e6f0517d8bd8782c9bb75abcce8ab8247be707ba066dc90b7fc12ff
-mpfr-4.2.1.tar.bz2/md5/7765afa036e4ce7fb0e02bce0fef894b
-mpfr-4.2.1.tar.bz2/sha512/c81842532ecc663348deb7400d911ad71933d3b525a2f9e5adcd04265c9c0fdd1f22eca229f482703ac7f222ef209fc9e339dd1fa47d72ae57f7f70b2336a76f
+MPFR.v4.2.2+0.aarch64-apple-darwin.tar.gz/md5/01a13215fd646c761e469f36f693fdc8
+MPFR.v4.2.2+0.aarch64-apple-darwin.tar.gz/sha512/da473776ac8c687ab34792235ee5e1e08dc6a2e29b73620bd6dac93db32397037ae502b8ac3a35e020f722dae7da007a060e5e11e3287c4cdb846bf7e5168297
+MPFR.v4.2.2+0.aarch64-linux-gnu.tar.gz/md5/58ca9f3e08a388c3e40692e623f3884e
+MPFR.v4.2.2+0.aarch64-linux-gnu.tar.gz/sha512/c6846d982ce1211791b466ed6fed2aad9e5f9a4866c48db99eb288dcbb1480660772010869fdea66d6453c8c140c92e367cfe55f6087fe41ea040fbd77eafe34
+MPFR.v4.2.2+0.aarch64-linux-musl.tar.gz/md5/2ff7e1400f27d049e3274a6277322860
+MPFR.v4.2.2+0.aarch64-linux-musl.tar.gz/sha512/388f7050288be9d30c4a2e772c0859e414b0cf6dbc845eec0eb6aeda53595df94a4e3001d02fa04c173fcf74e00c2552a8880b62ebf5adf443da2a95497be891
+MPFR.v4.2.2+0.aarch64-unknown-freebsd.tar.gz/md5/d1e6c477ab9678d1cd1dfa7e00366e69
+MPFR.v4.2.2+0.aarch64-unknown-freebsd.tar.gz/sha512/897174756651d01272d86bb147f5dda9f84f8f1bf1fe02b8505e141df3cc38523019f85cbe538fcc6ea8073d7743fc6428a06271107b059de80cd8f959c52daa
+MPFR.v4.2.2+0.armv6l-linux-gnueabihf.tar.gz/md5/5213b0ef1b191c529e3335e05b918003
+MPFR.v4.2.2+0.armv6l-linux-gnueabihf.tar.gz/sha512/bbcdb90f80d8cb826cd055eb41f051890c7847fc0887389b61bd24c051d35873af36672e5f1956cc3fb23b8e3ee50ee069c185fc2faabe302787d70210bd5b07
+MPFR.v4.2.2+0.armv6l-linux-musleabihf.tar.gz/md5/9a9d9207a6b52b6e84b1b2b1c631e0f2
+MPFR.v4.2.2+0.armv6l-linux-musleabihf.tar.gz/sha512/fd40d16a40b1db2b441339e5c8cb3f8a1810d2889713b0504f9bfd5451f4f4c2dd0ca35a4b2922feca9cf50e4a9b3bf8cf2c088655dd85a23c33ee67c12e0a72
+MPFR.v4.2.2+0.armv7l-linux-gnueabihf.tar.gz/md5/44532dd5607ced01a8ba0856c3bfdbc3
+MPFR.v4.2.2+0.armv7l-linux-gnueabihf.tar.gz/sha512/469fc030f458bd52f6bdffc442ceaaf8659f0f1e40d581eb1303fd4753d2c665fcb75bc6c54d04eb53d77b1945d67f48a5ea5614f2ee82cc7fd27e89859b45f4
+MPFR.v4.2.2+0.armv7l-linux-musleabihf.tar.gz/md5/fbd13b054b8d27be6bc836283f7846bf
+MPFR.v4.2.2+0.armv7l-linux-musleabihf.tar.gz/sha512/926dc03f99a6827c833614d17c5ef4f80fb862bdf4397db9aaf8ae9b3a66e8b9121cfa044b18db46f5774abbd7e9c129363183ccb2ae3192084711e7ff9d6382
+MPFR.v4.2.2+0.i686-linux-gnu.tar.gz/md5/da6fbb90dc20830af9325cfaf3544e4c
+MPFR.v4.2.2+0.i686-linux-gnu.tar.gz/sha512/d235884e1d1bef406b1e5ceb9c34aab68c1a8040b2022964105238ef8cdfd4af7aebe474fef80849689ca88d9168697fd55e8d6ab92b6641a1f37c431d5e3ff3
+MPFR.v4.2.2+0.i686-linux-musl.tar.gz/md5/fc885092e1469a06aaaaf24168e8fafe
+MPFR.v4.2.2+0.i686-linux-musl.tar.gz/sha512/5307926e1222b302e48e2f5c08479b920279d15b95937a245e16ac1dfd5c6206cb64fe4b6ca4cb7d6be847d8cc01a04d2661a630b978dc2dbd60605d222b8b21
+MPFR.v4.2.2+0.i686-w64-mingw32.tar.gz/md5/55f129d5b5b849b3bc018e68ccf14914
+MPFR.v4.2.2+0.i686-w64-mingw32.tar.gz/sha512/9a24e4616e05f5c1fb53e7a12167f7a55d05ec1895124d6ee23b2efd548f49e4c7995c16d240ec803f352d586ae4667027ee0bdeefa520e0c1f581fcc338dc44
+MPFR.v4.2.2+0.powerpc64le-linux-gnu.tar.gz/md5/6f47e4cde45ddf0cb2ea4f31ef9c9e04
+MPFR.v4.2.2+0.powerpc64le-linux-gnu.tar.gz/sha512/4fd8fbe166e719c636e430d4d5c938231fa9126b29eacbc678d2eb50d3d4b95cf6ccef155ce401c6d33b9730c2f89c0c77ec8fb39254483c2e4004639c503c1c
+MPFR.v4.2.2+0.riscv64-linux-gnu.tar.gz/md5/c4736705ff2a55cf8206c3af84bfc417
+MPFR.v4.2.2+0.riscv64-linux-gnu.tar.gz/sha512/e1e77d64ee88de2990fbc791d7307afe859cfbdc1ac67e7bdfa633627b5542ce2e3ee0cd9fe4036abfaf60509277a43f263e2155665ac2c5e38b8627e470f399
+MPFR.v4.2.2+0.x86_64-apple-darwin.tar.gz/md5/c3e983178a1e9600f42714d4cc1ecdf6
+MPFR.v4.2.2+0.x86_64-apple-darwin.tar.gz/sha512/c5c6cebcdfc5b7b84e9e217a81d99e5af78d163949745d570af5689210b3eedeb9de3c11991b1b36d8fdbee17b550a4072af951d19c3f863cf24cda7d9c12950
+MPFR.v4.2.2+0.x86_64-linux-gnu.tar.gz/md5/61fc7c7aa676d0a07e1709b433a8e423
+MPFR.v4.2.2+0.x86_64-linux-gnu.tar.gz/sha512/74bdefa72c51c82ca709e3494cd664a6593173bbfbe0198f18f4c0add06ce4c1217e4dd49e99cb151d71c85cd696ae2147aed29ed2cf3f1ca0e5b40582abb571
+MPFR.v4.2.2+0.x86_64-linux-musl.tar.gz/md5/207ee8ad2293ba36d3d7bb845ab346e0
+MPFR.v4.2.2+0.x86_64-linux-musl.tar.gz/sha512/63325e6595861a324f3c299d8c51b1d665197217c8fc9a5ae627b624037394f050bb08a9acd14e9809f982942c066f1185dded0fa493f360bcd3baae17a05f92
+MPFR.v4.2.2+0.x86_64-unknown-freebsd.tar.gz/md5/74e5a5ce0ea84959ccec7b7f7ab22c66
+MPFR.v4.2.2+0.x86_64-unknown-freebsd.tar.gz/sha512/411dbb339218669af6181fdf1e17f926abb9830ae54a8f9ef1b7df53021e8da01a41fda13067731afaf9b803324d5f82c060ef5b5b91045625188458b99dcc75
+MPFR.v4.2.2+0.x86_64-w64-mingw32.tar.gz/md5/2de84b494ea832147be4f9bfa786cd19
+MPFR.v4.2.2+0.x86_64-w64-mingw32.tar.gz/sha512/5f86aef6ab4fd7517cb23ad9a32ae21954a3ce1f27f5cbd28abe038271e20197b7c241055092a4aa6d5391f012bdee10465c58b53acd64bb5b99fd754c75ad29
+mpfr-4.2.2.tar.bz2/md5/afe8268360bc8702fbc8297d351c8b5e
+mpfr-4.2.2.tar.bz2/sha512/0176e50808dcc07afbf5bc3e38bf9b7b21918e5f194aa0bfd860d99b00c470630aef149776c4be814a61c44269c3a5b9a4b0b1c0fcd4c9feb1459d8466452da8
diff --git a/deps/mpfr.version b/deps/mpfr.version
index ec109e181ecdc..70585f95a6385 100644
--- a/deps/mpfr.version
+++ b/deps/mpfr.version
@@ -1,5 +1,6 @@
+# -*- makefile -*-
 ## jll artifact
 MPFR_JLL_NAME := MPFR
 
 ## source build
-MPFR_VER := 4.2.1
+MPFR_VER := 4.2.2
diff --git a/stdlib/MPFR_jll/Project.toml b/stdlib/MPFR_jll/Project.toml
index 50de38f169ff0..9958383f4e65b 100644
--- a/stdlib/MPFR_jll/Project.toml
+++ b/stdlib/MPFR_jll/Project.toml
@@ -1,6 +1,6 @@
 name = "MPFR_jll"
 uuid = "3a97d323-0669-5f0c-9066-3539efd106a3"
-version = "4.2.1+2"
+version = "4.2.2+0"
 
 [deps]
 GMP_jll = "781609d7-10c4-51f6-84f2-b8444358ff6d"
diff --git a/stdlib/MPFR_jll/test/runtests.jl b/stdlib/MPFR_jll/test/runtests.jl
index fc931b462fa9c..1dbbbb298e737 100644
--- a/stdlib/MPFR_jll/test/runtests.jl
+++ b/stdlib/MPFR_jll/test/runtests.jl
@@ -4,5 +4,5 @@ using Test, Libdl, MPFR_jll
 
 @testset "MPFR_jll" begin
     vn = VersionNumber(unsafe_string(ccall((:mpfr_get_version,libmpfr), Cstring, ())))
-    @test vn == v"4.2.1"
+    @test vn == v"4.2.2"
 end
diff --git a/stdlib/Manifest.toml b/stdlib/Manifest.toml
index b149532d7b203..1aa9d3b9082a7 100644
--- a/stdlib/Manifest.toml
+++ b/stdlib/Manifest.toml
@@ -136,7 +136,7 @@ version = "1.11.0"
 [[deps.MPFR_jll]]
 deps = ["Artifacts", "GMP_jll", "Libdl"]
 uuid = "3a97d323-0669-5f0c-9066-3539efd106a3"
-version = "4.2.1+1"
+version = "4.2.2+0"
 
 [[deps.Markdown]]
 deps = ["Base64", "JuliaSyntaxHighlighting", "StyledStrings"]

From ebdb9c0116ad1e077235cf178ec550e99a59ae2d Mon Sep 17 00:00:00 2001
From: Ian Butterworth <i.r.butterworth@gmail.com>
Date: Thu, 10 Apr 2025 11:48:16 -0400
Subject: [PATCH 14/38] Remove try-finally scope from `@time_imports`
 `@trace_compile` `@trace_dispatch` (#58011)

Matches `@time` `@profile` etc.

(cherry picked from commit 1117df66f2f199e7224697d110d023add4231579)
---
 base/timing.jl | 33 ++++++++++++++++++---------------
 1 file changed, 18 insertions(+), 15 deletions(-)

diff --git a/base/timing.jl b/base/timing.jl
index 61fa73f2eff62..2dabe964f08c6 100644
--- a/base/timing.jl
+++ b/base/timing.jl
@@ -643,33 +643,36 @@ end
 # here so it's possible to time/trace all imports, including InteractiveUtils and its deps
 macro time_imports(ex)
     quote
-        try
-            Base.Threads.atomic_add!(Base.TIMING_IMPORTS, 1)
-            $(esc(ex))
-        finally
+        Base.Threads.atomic_add!(Base.TIMING_IMPORTS, 1)
+        @__tryfinally(
+            # try
+            $(esc(ex)),
+            # finally
             Base.Threads.atomic_sub!(Base.TIMING_IMPORTS, 1)
-        end
+        )
     end
 end
 
 macro trace_compile(ex)
     quote
-        try
-            ccall(:jl_force_trace_compile_timing_enable, Cvoid, ())
-            $(esc(ex))
-        finally
+        ccall(:jl_force_trace_compile_timing_enable, Cvoid, ())
+        @__tryfinally(
+            # try
+            $(esc(ex)),
+            # finally
             ccall(:jl_force_trace_compile_timing_disable, Cvoid, ())
-        end
+        )
     end
 end
 
 macro trace_dispatch(ex)
     quote
-        try
-            ccall(:jl_force_trace_dispatch_enable, Cvoid, ())
-            $(esc(ex))
-        finally
+        ccall(:jl_force_trace_dispatch_enable, Cvoid, ())
+        @__tryfinally(
+            # try
+            $(esc(ex)),
+            # finally
             ccall(:jl_force_trace_dispatch_disable, Cvoid, ())
-        end
+        )
     end
 end

From a7e989960ae7f29a10889153f72465bfd1908d21 Mon Sep 17 00:00:00 2001
From: Jeff Bezanson <jeff.bezanson@gmail.com>
Date: Thu, 10 Apr 2025 18:37:19 -0400
Subject: [PATCH 15/38] fix #58013, error for too few arguments in
 `invokelatest` (#58056)

Also a couple builtins had the wrong function name in their error
messages.
fix #58013

(cherry picked from commit 90eb96fe45804b6cd76885e9798f5ca6acf41552)
---
 src/builtins.c | 7 ++++---
 test/worlds.jl | 3 +++
 2 files changed, 7 insertions(+), 3 deletions(-)

diff --git a/src/builtins.c b/src/builtins.c
index 243d14f34d3bd..0f39c4783e4cd 100644
--- a/src/builtins.c
+++ b/src/builtins.c
@@ -846,6 +846,7 @@ JL_CALLABLE(jl_f__apply_iterate)
 // this is like a regular call, but always runs in the newest world
 JL_CALLABLE(jl_f_invokelatest)
 {
+    JL_NARGSV(invokelatest, 1);
     jl_task_t *ct = jl_current_task;
     size_t last_age = ct->world_age;
     if (!ct->ptls->in_pure_callback)
@@ -859,10 +860,10 @@ JL_CALLABLE(jl_f_invokelatest)
 // If world > jl_atomic_load_acquire(&jl_world_counter), run in the latest world.
 JL_CALLABLE(jl_f_invoke_in_world)
 {
-    JL_NARGSV(_apply_in_world, 2);
+    JL_NARGSV(invoke_in_world, 2);
     jl_task_t *ct = jl_current_task;
     size_t last_age = ct->world_age;
-    JL_TYPECHK(_apply_in_world, ulong, args[0]);
+    JL_TYPECHK(invoke_in_world, ulong, args[0]);
     size_t world = jl_unbox_ulong(args[0]);
     if (!ct->ptls->in_pure_callback) {
         ct->world_age = jl_atomic_load_acquire(&jl_world_counter);
@@ -877,7 +878,7 @@ JL_CALLABLE(jl_f_invoke_in_world)
 JL_CALLABLE(jl_f__call_in_world_total)
 {
     JL_NARGSV(_call_in_world_total, 2);
-    JL_TYPECHK(_apply_in_world, ulong, args[0]);
+    JL_TYPECHK(_call_in_world_total, ulong, args[0]);
     jl_task_t *ct = jl_current_task;
     int last_in = ct->ptls->in_pure_callback;
     jl_value_t *ret = NULL;
diff --git a/test/worlds.jl b/test/worlds.jl
index 686708c5efd27..4520ab257d078 100644
--- a/test/worlds.jl
+++ b/test/worlds.jl
@@ -5,6 +5,9 @@
 using Base: get_world_counter, tls_world_age
 @test typemax(UInt) > get_world_counter() == tls_world_age() > 0
 
+# issue #58013
+@test_throws ArgumentError invokelatest()
+
 # test simple method replacement
 begin
     g265a() = f265a(0)

From c4b679858d4c88db25b004e9b4086228fb23eb5e Mon Sep 17 00:00:00 2001
From: Neven Sajko <4944410+nsajko@users.noreply.github.com>
Date: Sun, 13 Apr 2025 08:08:55 +0200
Subject: [PATCH 16/38] fix zero-dimensional `reverse!` (#58086)

Also changed the check to compare against the tuple argument, instead of
against the method static parameter for the tuple length. Should be
better when the length isn't known at compile time.

Fixes #58085

(cherry picked from commit b265dbac3ef8d1f8f7d779044f458a3c5e2b4689)
---
 base/arraymath.jl | 2 +-
 test/arrayops.jl  | 6 ++++++
 2 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/base/arraymath.jl b/base/arraymath.jl
index 62dc3772e4938..53a7d132a2c0c 100644
--- a/base/arraymath.jl
+++ b/base/arraymath.jl
@@ -72,12 +72,12 @@ _reverse!(A::AbstractArray{<:Any,N}, ::Colon) where {N} = _reverse!(A, ntuple(id
 _reverse!(A, dim::Integer) = _reverse!(A, (Int(dim),))
 _reverse!(A, dims::NTuple{M,Integer}) where {M} = _reverse!(A, Int.(dims))
 function _reverse!(A::AbstractArray{<:Any,N}, dims::NTuple{M,Int}) where {N,M}
+    dims === () && return A # nothing to reverse
     dimrev = ntuple(k -> k in dims, Val{N}()) # boolean tuple indicating reversed dims
 
     if N < M || M != sum(dimrev)
         throw(ArgumentError("invalid dimensions $dims in reverse!"))
     end
-    M == 0 && return A # nothing to reverse
 
     # swapping loop only needs to traverse ≈half of the array
     halfsz = ntuple(k -> k == dims[1] ? size(A,k) ÷ 2 : size(A,k), Val{N}())
diff --git a/test/arrayops.jl b/test/arrayops.jl
index b2da3eac6386b..d5fba79c47017 100644
--- a/test/arrayops.jl
+++ b/test/arrayops.jl
@@ -1761,6 +1761,12 @@ end
     end
 end
 
+@testset "reverse zero dims" begin
+    a = fill(3)
+    @test a == reverse(a)
+    @test a === reverse!(a)
+end
+
 @testset "isdiag, istril, istriu" begin
     # Scalar
     @test isdiag(3)

From 2decc5762d331d08b88e441db4a8b8b2aabefdea Mon Sep 17 00:00:00 2001
From: Alex Wadell <awadell@gmail.com>
Date: Mon, 14 Apr 2025 22:12:26 -0400
Subject: [PATCH 17/38] Fix `--project=@script` when outside script directory
 (#56351)

(cherry picked from commit d9764d68aed9d7bfe0715afa5ba0229c905fba98)
---
 base/initdefs.jl                              | 24 +++++++------------
 base/options.jl                               |  1 +
 src/jloptions.c                               |  7 ++++--
 src/jloptions.h                               |  1 +
 test/cmdlineargs.jl                           | 10 ++++++++
 test/project/ScriptProject/Project.toml       |  2 ++
 .../ScriptProject/SubProject/Project.toml     |  2 ++
 test/project/ScriptProject/bin/script.jl      |  1 +
 8 files changed, 30 insertions(+), 18 deletions(-)
 create mode 100644 test/project/ScriptProject/Project.toml
 create mode 100644 test/project/ScriptProject/SubProject/Project.toml
 create mode 100644 test/project/ScriptProject/bin/script.jl

diff --git a/base/initdefs.jl b/base/initdefs.jl
index f7693813239c6..90f213c468bba 100644
--- a/base/initdefs.jl
+++ b/base/initdefs.jl
@@ -284,22 +284,14 @@ function load_path_expand(env::AbstractString)::Union{String, Nothing}
         env == "@temp" && return mktempdir()
         env == "@stdlib" && return Sys.STDLIB
         if startswith(env, "@script")
-            if @isdefined(PROGRAM_FILE)
-                dir = dirname(PROGRAM_FILE)
-            else
-                cmds = unsafe_load_commands(JLOptions().commands)
-                if any(cmd::Pair{Char, String}->cmd_suppresses_program(first(cmd)), cmds)
-                    # Usage error. The user did not pass a script.
-                    return nothing
-                end
-                dir = dirname(ARGS[1])
-            end
-            if env == "@script"  # complete match, not startswith, so search upwards
-                return current_project(dir)
-            else
-                # starts with, so assume relative path is after
-                return abspath(replace(env, "@script" => dir))
-            end
+            program_file = JLOptions().program_file
+            program_file = program_file != C_NULL ? unsafe_string(program_file) : nothing
+            isnothing(program_file) && return nothing # User did not pass a script
+
+            # Expand trailing relative path
+            dir = dirname(program_file)
+            dir = env != "@script" ? (dir * env[length("@script")+1:end]) : dir
+            return current_project(dir)
         end
         env = replace(env, '#' => VERSION.major, count=1)
         env = replace(env, '#' => VERSION.minor, count=1)
diff --git a/base/options.jl b/base/options.jl
index 3281ec0de98d2..818fd33d6f7fc 100644
--- a/base/options.jl
+++ b/base/options.jl
@@ -17,6 +17,7 @@ struct JLOptions
     nprocs::Int32
     machine_file::Ptr{UInt8}
     project::Ptr{UInt8}
+    program_file::Ptr{UInt8}
     isinteractive::Int8
     color::Int8
     historyfile::Int8
diff --git a/src/jloptions.c b/src/jloptions.c
index ac515bea19845..79afe65ea9bf7 100644
--- a/src/jloptions.c
+++ b/src/jloptions.c
@@ -104,6 +104,7 @@ JL_DLLEXPORT void jl_init_options(void)
                         0,    // nprocs
                         NULL, // machine_file
                         NULL, // project
+                        NULL, // program_file
                         0,    // isinteractive
                         0,    // color
                         JL_OPTIONS_HISTORYFILE_ON, // history file
@@ -169,11 +170,12 @@ static const char opts[]  =
     " --help-hidden                                 Print uncommon options not shown by `-h`\n\n"
 
     // startup options
-    " --project[={<dir>|@temp|@.}]                  Set <dir> as the active project/environment.\n"
+    " --project[={<dir>|@temp|@.|@script[<rel>]}]   Set <dir> as the active project/environment.\n"
     "                                               Or, create a temporary environment with `@temp`\n"
     "                                               The default @. option will search through parent\n"
     "                                               directories until a Project.toml or JuliaProject.toml\n"
-    "                                               file is found.\n"
+    "                                               file is found. @script is similar, but searches up from\n"
+    "                                               the programfile or a path relative to programfile.\n"
     " -J, --sysimage <file>                         Start up with the given system image file\n"
     " -H, --home <dir>                              Set location of `julia` executable\n"
     " --startup-file={yes*|no}                      Load `JULIA_DEPOT_PATH/config/startup.jl`; \n"
@@ -1012,6 +1014,7 @@ JL_DLLEXPORT void jl_parse_opts(int *argcp, char ***argvp)
                       "This is a bug, please report it.", c);
         }
     }
+    jl_options.program_file = optind < argc ? strdup(argv[optind]) : "";
     parsing_args_done:
     if (!jl_options.use_experimental_features) {
         if (jl_options.trim != JL_TRIM_NO)
diff --git a/src/jloptions.h b/src/jloptions.h
index a8cc4a9a9e33d..06e00e9309dba 100644
--- a/src/jloptions.h
+++ b/src/jloptions.h
@@ -21,6 +21,7 @@ typedef struct {
     int32_t nprocs;
     const char *machine_file;
     const char *project;
+    const char *program_file;
     int8_t isinteractive;
     int8_t color;
     int8_t historyfile;
diff --git a/test/cmdlineargs.jl b/test/cmdlineargs.jl
index 0556a243cbf37..f78e72f21b950 100644
--- a/test/cmdlineargs.jl
+++ b/test/cmdlineargs.jl
@@ -257,6 +257,16 @@ let exename = `$(Base.julia_cmd()) --startup-file=no --color=no`
         @test expanded == readchomp(addenv(`$exename -e 'println(Base.active_project())'`, "JULIA_PROJECT" => "@foo", "HOME" => homedir()))
     end
 
+    # --project=@script handling
+    let expanded = abspath(joinpath(@__DIR__, "project", "ScriptProject"))
+        script = joinpath(expanded, "bin", "script.jl")
+        # Check running julia with --project=@script both within and outside the script directory
+        @testset "--@script from $name" for (name, dir) in [("project", expanded), ("outside", pwd())]
+            @test joinpath(expanded, "Project.toml") == readchomp(Cmd(`$exename --project=@script $script`; dir))
+            @test joinpath(expanded, "SubProject", "Project.toml") == readchomp(Cmd(`$exename --project=@script/../SubProject $script`; dir))
+        end
+    end
+
     # handling of `@temp` in --project and JULIA_PROJECT
     @test tempdir() == readchomp(`$exename --project=@temp -e 'println(Base.active_project())'`)[1:lastindex(tempdir())]
     @test tempdir() == readchomp(addenv(`$exename -e 'println(Base.active_project())'`, "JULIA_PROJECT" => "@temp", "HOME" => homedir()))[1:lastindex(tempdir())]
diff --git a/test/project/ScriptProject/Project.toml b/test/project/ScriptProject/Project.toml
new file mode 100644
index 0000000000000..3301f2b79da83
--- /dev/null
+++ b/test/project/ScriptProject/Project.toml
@@ -0,0 +1,2 @@
+name = "ScriptProject"
+uuid = "6646321a-c4de-46ad-9761-435e5bb1f223"
diff --git a/test/project/ScriptProject/SubProject/Project.toml b/test/project/ScriptProject/SubProject/Project.toml
new file mode 100644
index 0000000000000..e6c472c7a33f6
--- /dev/null
+++ b/test/project/ScriptProject/SubProject/Project.toml
@@ -0,0 +1,2 @@
+name = "SubProject"
+uuid = "50d58d6a-5ae2-46f7-9677-83c51ca667d5"
diff --git a/test/project/ScriptProject/bin/script.jl b/test/project/ScriptProject/bin/script.jl
new file mode 100644
index 0000000000000..e38351c9ab9a8
--- /dev/null
+++ b/test/project/ScriptProject/bin/script.jl
@@ -0,0 +1 @@
+println(Base.active_project())

From 65657d1cc1a02bb7614c0eb93c6d7d684c2260c5 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Tue, 15 Apr 2025 13:10:00 -0400
Subject: [PATCH 18/38] prevent allocation of Memory (layout and object) when
 not concrete (#58064)

Fix #54969

(cherry picked from commit cca5ac75406b7e728a5ff3802b76fab16975ac2a)
---
 src/datatype.c | 8 +++++++-
 src/julia.h    | 2 +-
 test/core.jl   | 3 +++
 3 files changed, 11 insertions(+), 2 deletions(-)

diff --git a/src/datatype.c b/src/datatype.c
index 9c2360c7eeccb..4c7e248cf0a52 100644
--- a/src/datatype.c
+++ b/src/datatype.c
@@ -500,7 +500,13 @@ void jl_get_genericmemory_layout(jl_datatype_t *st)
     jl_value_t *kind = jl_tparam0(st);
     jl_value_t *eltype = jl_tparam1(st);
     jl_value_t *addrspace = jl_tparam2(st);
-    if (!jl_is_typevar(eltype) && !jl_is_type(eltype)) {
+    if (!st->isconcretetype) {
+        // Since parent dt has an opaque layout, we may end up here being asked to copy that layout to subtypes,
+        // but we don't actually want to do that unless this object is constructable (or at least has a layout).
+        // The real layout is stored only on the wrapper.
+        return;
+    }
+    if (!jl_is_type(eltype)) {
         // this is expected to have a layout, but since it is not constructable, we don't care too much what it is
         static const jl_datatype_layout_t opaque_ptr_layout = {0, 0, 1, -1, sizeof(void*), {0}};
         st->layout = &opaque_ptr_layout;
diff --git a/src/julia.h b/src/julia.h
index 4b38671f17da4..6799558ef593d 100644
--- a/src/julia.h
+++ b/src/julia.h
@@ -1505,7 +1505,7 @@ JL_DLLEXPORT jl_value_t *jl_unwrap_unionall(jl_value_t *v JL_PROPAGATES_ROOT) JL
 #define jl_inlinedatatype_layout(t) (((jl_datatype_t*)t)->layout)
 STATIC_INLINE const jl_datatype_layout_t *jl_datatype_layout(jl_datatype_t *t) JL_NOTSAFEPOINT
 {
-    if (jl_is_layout_opaque(t->layout)) // e.g. GenericMemory
+    if (t->layout == NULL || jl_is_layout_opaque(t->layout)) // e.g. GenericMemory
         t = (jl_datatype_t*)jl_unwrap_unionall(t->name->wrapper);
     return t->layout;
 }
diff --git a/test/core.jl b/test/core.jl
index 97601e7c0c21a..181fe302eb5a4 100644
--- a/test/core.jl
+++ b/test/core.jl
@@ -4951,6 +4951,9 @@ let ft = Base.datatype_fieldtypes
     @test !isdefined(ft(B12238.body.body)[1], :instance)  # has free type vars
 end
 
+# issue #54969
+@test !isdefined(Memory.body, :instance)
+
 # `where` syntax in constructor definitions
 (A12238{T} where T<:Real)(x) = 0
 @test A12238{<:Real}(0) == 0

From e0a1611a1bf8b1ede2f4c09bb8301997ddfdb16d Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Tue, 15 Apr 2025 13:10:18 -0400
Subject: [PATCH 19/38] much faster code-coverage for packages (#57988)

We already have an excellent framework for selective code reuse, so use
that tool instead of a sledgehammer for inserting selective coverage and
malloc instrumentation. As a small bonus, this should also be
significantly more accurate by not being vulnerable to precompilation
inserting incorrect (uninstrumented) contents into the caches.

(cherry picked from commit 5fedf470f04f0ac04dbf346b822ca1edaf189f42)
---
 Compiler/src/inferencestate.jl | 24 +++++++------
 Compiler/src/utilities.jl      | 13 ++++++-
 base/loading.jl                | 47 ++----------------------
 base/staticdata.jl             | 65 +++++++++++++++++++++++++++++-----
 4 files changed, 85 insertions(+), 64 deletions(-)

diff --git a/Compiler/src/inferencestate.jl b/Compiler/src/inferencestate.jl
index 659b867128177..dc9430169ab82 100644
--- a/Compiler/src/inferencestate.jl
+++ b/Compiler/src/inferencestate.jl
@@ -575,21 +575,23 @@ function (::ComputeTryCatch{Handler})(code::Vector{Any}, bbs::Union{Vector{Basic
 end
 
 # check if coverage mode is enabled
-function should_insert_coverage(mod::Module, debuginfo::DebugInfo)
-    coverage_enabled(mod) && return true
-    JLOptions().code_coverage == 3 || return false
+should_insert_coverage(mod::Module, debuginfo::DebugInfo) = should_instrument(mod, debuginfo, true)
+
+function should_instrument(mod::Module, debuginfo::DebugInfo, only_if_affects_optimizer::Bool=false)
+    instrumentation_enabled(mod, only_if_affects_optimizer) && return true
+    JLOptions().code_coverage == 3 || JLOptions().malloc_log == 3 || return false
     # path-specific coverage mode: if any line falls in a tracked file enable coverage for all
-    return _should_insert_coverage(debuginfo)
+    return _should_instrument(debuginfo)
 end
 
-_should_insert_coverage(mod::Symbol) = is_file_tracked(mod)
-_should_insert_coverage(mod::Method) = _should_insert_coverage(mod.file)
-_should_insert_coverage(mod::MethodInstance) = _should_insert_coverage(mod.def)
-_should_insert_coverage(mod::Module) = false
-function _should_insert_coverage(info::DebugInfo)
+_should_instrument(loc::Symbol) = is_file_tracked(loc)
+_should_instrument(loc::Method) = _should_instrument(loc.file)
+_should_instrument(loc::MethodInstance) = _should_instrument(loc.def)
+_should_instrument(loc::Module) = false
+function _should_instrument(info::DebugInfo)
     linetable = info.linetable
-    linetable === nothing || (_should_insert_coverage(linetable) && return true)
-    _should_insert_coverage(info.def) && return true
+    linetable === nothing || (_should_instrument(linetable) && return true)
+    _should_instrument(info.def) && return true
     return false
 end
 
diff --git a/Compiler/src/utilities.jl b/Compiler/src/utilities.jl
index 477c518518918..dfcff03d70f0e 100644
--- a/Compiler/src/utilities.jl
+++ b/Compiler/src/utilities.jl
@@ -329,7 +329,7 @@ end
 
 inlining_enabled() = (JLOptions().can_inline == 1)
 
-function coverage_enabled(m::Module)
+function instrumentation_enabled(m::Module, only_if_affects_optimizer::Bool)
     generating_output() && return false # don't alter caches
     cov = JLOptions().code_coverage
     if cov == 1 # user
@@ -340,6 +340,17 @@ function coverage_enabled(m::Module)
     elseif cov == 2 # all
         return true
     end
+    if !only_if_affects_optimizer
+        log = JLOptions().malloc_log
+        if log == 1 # user
+            m = moduleroot(m)
+            m === Core && return false
+            isdefined(Main, :Base) && m === Main.Base && return false
+            return true
+        elseif log == 2 # all
+            return true
+        end
+    end
     return false
 end
 
diff --git a/base/loading.jl b/base/loading.jl
index 89eecb3ec1fbc..ea2cf35395540 100644
--- a/base/loading.jl
+++ b/base/loading.jl
@@ -1243,21 +1243,7 @@ const TIMING_IMPORTS = Threads.Atomic{Int}(0)
 # these return either the array of modules loaded from the path / content given
 # or an Exception that describes why it couldn't be loaded
 # and it reconnects the Base.Docs.META
-function _include_from_serialized(pkg::PkgId, path::String, ocachepath::Union{Nothing, String}, depmods::Vector{Any}, ignore_native::Union{Nothing,Bool}=nothing; register::Bool=true)
-    if isnothing(ignore_native)
-        if JLOptions().code_coverage == 0 && JLOptions().malloc_log == 0
-            ignore_native = false
-        else
-            io = open(path, "r")
-            try
-                iszero(isvalid_cache_header(io)) && return ArgumentError("Incompatible header in cache file $path.")
-                _, (includes, _, _), _, _, _, _, _, _ = parse_cache_header(io, path)
-                ignore_native = pkg_tracked(includes)
-            finally
-                close(io)
-            end
-        end
-    end
+function _include_from_serialized(pkg::PkgId, path::String, ocachepath::Union{Nothing, String}, depmods::Vector{Any}; register::Bool=true)
     assert_havelock(require_lock)
     timing_imports = TIMING_IMPORTS[] > 0
     try
@@ -1276,6 +1262,7 @@ function _include_from_serialized(pkg::PkgId, path::String, ocachepath::Union{No
             depmods[i] = dep
         end
 
+        ignore_native = false
         unlock(require_lock) # temporarily _unlock_ during these operations
         sv = try
             if ocachepath !== nothing
@@ -1945,44 +1932,16 @@ function _tryrequire_from_serialized(modkey::PkgId, build_id::UInt128)
     return ErrorException("Required dependency $modkey failed to load from a cache file.")
 end
 
-# returns whether the package is tracked in coverage or malloc tracking based on
-# JLOptions and includes
-function pkg_tracked(includes)
-    if JLOptions().code_coverage == 0 && JLOptions().malloc_log == 0
-        return false
-    elseif JLOptions().code_coverage == 1 || JLOptions().malloc_log == 1 # user
-        # Just say true. Pkgimages aren't in Base
-        return true
-    elseif JLOptions().code_coverage == 2 || JLOptions().malloc_log == 2 # all
-        return true
-    elseif JLOptions().code_coverage == 3 || JLOptions().malloc_log == 3 # tracked path
-        if JLOptions().tracked_path == C_NULL
-            return false
-        else
-            tracked_path = unsafe_string(JLOptions().tracked_path)
-            if isempty(tracked_path)
-                return false
-            else
-                return any(includes) do inc
-                    startswith(inc.filename, tracked_path)
-                end
-            end
-        end
-    end
-end
-
 # loads a precompile cache file, ignoring stale_cachefile tests
 # load all dependent modules first
 function _tryrequire_from_serialized(pkg::PkgId, path::String, ocachepath::Union{Nothing, String})
     assert_havelock(require_lock)
     local depmodnames
     io = open(path, "r")
-    ignore_native = false
     try
         iszero(isvalid_cache_header(io)) && return ArgumentError("Incompatible header in cache file $path.")
         _, (includes, _, _), depmodnames, _, _, _, clone_targets, _ = parse_cache_header(io, path)
 
-        ignore_native = pkg_tracked(includes)
 
         pkgimage = !isempty(clone_targets)
         if pkgimage
@@ -2009,7 +1968,7 @@ function _tryrequire_from_serialized(pkg::PkgId, path::String, ocachepath::Union
         depmods[i] = dep
     end
     # then load the file
-    loaded = _include_from_serialized(pkg, path, ocachepath, depmods, ignore_native; register = true)
+    loaded = _include_from_serialized(pkg, path, ocachepath, depmods; register = true)
     return loaded
 end
 
diff --git a/base/staticdata.jl b/base/staticdata.jl
index d51e7892bbe56..741937369b73b 100644
--- a/base/staticdata.jl
+++ b/base/staticdata.jl
@@ -2,8 +2,8 @@
 
 module StaticData
 
-using Core: CodeInstance, MethodInstance
-using Base: get_world_counter
+using .Core: CodeInstance, MethodInstance
+using .Base: JLOptions, Compiler, get_world_counter, _methods_by_ftype, get_methodtable
 
 const WORLD_AGE_REVALIDATION_SENTINEL::UInt = 1
 const _jl_debug_method_invalidation = Ref{Union{Nothing,Vector{Any}}}(nothing)
@@ -73,6 +73,51 @@ end
 
 get_require_world() = unsafe_load(cglobal(:jl_require_world, UInt))
 
+function gen_staged_sig(def::Method, mi::MethodInstance)
+    isdefined(def, :generator) || return nothing
+    isdispatchtuple(mi.specTypes) || return nothing
+    gen = Core.Typeof(def.generator)
+    return Tuple{gen, UInt, Method, Vararg}
+    ## more precise method lookup, but more costly and likely not actually better?
+    #tts = (mi.specTypes::DataType).parameters
+    #sps = Any[Core.Typeof(mi.sparam_vals[i]) for i in 1:length(mi.sparam_vals)]
+    #if def.isva
+    #    return Tuple{gen, UInt, Method, sps..., tts[1:def.nargs - 1]..., Tuple{tts[def.nargs - 1:end]...}}
+    #else
+    #    return Tuple{gen, UInt, Method, sps..., tts...}
+    #end
+end
+
+function needs_instrumentation(codeinst::CodeInstance, mi::MethodInstance, def::Method, validation_world::UInt)
+    if JLOptions().code_coverage != 0 || JLOptions().malloc_log != 0
+        # test if the code needs to run with instrumentation, in which case we cannot use existing generated code
+        if isdefined(def, :debuginfo) ? # generated_only functions do not have debuginfo, so fall back to considering their codeinst debuginfo though this may be slower (and less accurate?)
+            Compiler.should_instrument(def.module, def.debuginfo) :
+            Compiler.should_instrument(def.module, codeinst.debuginfo)
+            return true
+        end
+        gensig = gen_staged_sig(def, mi)
+        if gensig !== nothing
+            # if this is defined by a generator, try to consider forcing re-running the generators too, to add coverage for them
+            minworld = Ref{UInt}(1)
+            maxworld = Ref{UInt}(typemax(UInt))
+            has_ambig = Ref{Int32}(0)
+            result = _methods_by_ftype(gensig, nothing, -1, validation_world, #=ambig=#false, minworld, maxworld, has_ambig)
+            if result !== nothing
+                for k = 1:length(result)
+                    match = result[k]::Core.MethodMatch
+                    genmethod = match.method
+                    # no, I refuse to refuse to recurse into your cursed generated function generators and will only test one level deep here
+                    if isdefined(genmethod, :debuginfo) && Compiler.should_instrument(genmethod.module, genmethod.debuginfo)
+                        return true
+                    end
+                end
+            end
+        end
+    end
+    return false
+end
+
 # Test all edges relevant to a method:
 # - Visit the entire call graph, starting from edges[idx] to determine if that method is valid
 # - Implements Tarjan's SCC (strongly connected components) algorithm, simplified to remove the count variable
@@ -84,6 +129,12 @@ function verify_method(codeinst::CodeInstance, stack::Vector{CodeInstance}, visi
             return 0, world, max_valid2
         end
     end
+    mi = get_ci_mi(codeinst)
+    def = mi.def::Method
+    if needs_instrumentation(codeinst, mi, def, validation_world)
+        return 0, world, UInt(0)
+    end
+
     # Implicitly referenced bindings in the current module do not get explicit edges.
     # If they were invalidated, they'll be in `mwis`. If they weren't, they imply a minworld
     # of `get_require_world`. In principle, this is only required for methods that do reference
@@ -92,8 +143,6 @@ function verify_method(codeinst::CodeInstance, stack::Vector{CodeInstance}, visi
     # but no implicit edges) is rare and there would be little benefit to lower the minworld for it
     # in any case, so we just always use `get_require_world` here.
     local minworld::UInt, maxworld::UInt = get_require_world(), validation_world
-    def = get_ci_mi(codeinst).def
-    @assert def isa Method
     if haskey(visiting, codeinst)
         return visiting[codeinst], minworld, maxworld
     end
@@ -225,7 +274,7 @@ function verify_method(codeinst::CodeInstance, stack::Vector{CodeInstance}, visi
         end
         @atomic :monotonic child.max_world = maxworld
         if maxworld == validation_world && validation_world == get_world_counter()
-            Base.Compiler.store_backedges(child, child.edges)
+            Compiler.store_backedges(child, child.edges)
         end
         @assert visiting[child] == length(stack) + 1
         delete!(visiting, child)
@@ -243,7 +292,7 @@ function verify_call(@nospecialize(sig), expecteds::Core.SimpleVector, i::Int, n
     minworld = Ref{UInt}(1)
     maxworld = Ref{UInt}(typemax(UInt))
     has_ambig = Ref{Int32}(0)
-    result = Base._methods_by_ftype(sig, nothing, lim, world, #=ambig=#false, minworld, maxworld, has_ambig)
+    result = _methods_by_ftype(sig, nothing, lim, world, #=ambig=#false, minworld, maxworld, has_ambig)
     if result === nothing
         maxworld[] = 0
     else
@@ -306,11 +355,11 @@ function verify_invokesig(@nospecialize(invokesig), expected::Method, world::UIn
     else
         minworld = 1
         maxworld = typemax(UInt)
-        mt = Base.get_methodtable(expected)
+        mt = get_methodtable(expected)
         if mt === nothing
             maxworld = 0
         else
-            matched, valid_worlds = Base.Compiler._findsup(invokesig, mt, world)
+            matched, valid_worlds = Compiler._findsup(invokesig, mt, world)
             minworld, maxworld = valid_worlds.min_world, valid_worlds.max_world
             if matched === nothing
                 maxworld = 0

From e207cf409ab7525dc9d4bfd952232dc147a73e1c Mon Sep 17 00:00:00 2001
From: Nathan Zimmerberg <39104088+nhz2@users.noreply.github.com>
Date: Tue, 15 Apr 2025 15:27:50 -0400
Subject: [PATCH 20/38] Fix `IOBuffer` `skip` regression (#57963)

Fixes #57962

This reverts the changes to `skip` added in #57570

The code before #57570 was written in a very specific way to avoid
overflow errors, so I'm not sure why this was changed.

(cherry picked from commit b29c80894ed0bd80c0d1cc98d11405f320289623)
---
 base/iobuffer.jl | 4 ++--
 test/iobuffer.jl | 7 +++++++
 2 files changed, 9 insertions(+), 2 deletions(-)

diff --git a/base/iobuffer.jl b/base/iobuffer.jl
index 5e08a21d53186..d121082f3585d 100644
--- a/base/iobuffer.jl
+++ b/base/iobuffer.jl
@@ -486,8 +486,8 @@ function skip(io::GenericIOBuffer, n::Int)
     else
         # Don't use seek in order to allow a non-seekable IO to still skip bytes.
         # Handle overflow.
-        maxptr = io.size + 1
-        io.ptr = n > maxptr || io.ptr - n > maxptr ? maxptr : io.ptr + n
+        n_max = io.size + 1 - io.ptr
+        io.ptr += min(n, n_max)
         io
     end
 end
diff --git a/test/iobuffer.jl b/test/iobuffer.jl
index 7ed5c1f5b3ed6..2b84fe79307ae 100644
--- a/test/iobuffer.jl
+++ b/test/iobuffer.jl
@@ -497,6 +497,13 @@ end
     end
 end
 
+@testset "issue #57962" begin
+    io = IOBuffer(repeat("x", 400))
+    skip(io, 10)
+    skip(io, 400)
+    @test isempty(read(io))
+end
+
 @testset "pr #11554" begin
     io  = IOBuffer(SubString("***αhelloworldω***", 4, 16))
     io2 = IOBuffer(Vector{UInt8}(b"goodnightmoon"), read=true, write=true)

From d3a569d364a64d7b250f58b5f784efe40c8cfe31 Mon Sep 17 00:00:00 2001
From: Stefan Karpinski <stefan@karpinski.org>
Date: Tue, 15 Apr 2025 16:00:59 -0400
Subject: [PATCH 21/38] [DOC] Update installation docs: /downloads/ =>
 /install/ (#58127)

I've created an [Install](https://julialang.org/install/) page separate
from the [Downloads](https://julialang.org/downloads/) page on the
website. This updates various references to point to the correct pages.

(cherry picked from commit 48660a617318c0907ed0b2a260c4c46672d975ed)
---
 README.md                         | 29 +++++++++++++++++------------
 doc/man/julia.1                   |  2 +-
 doc/src/devdocs/build/windows.md  |  2 +-
 doc/src/index.md                  |  2 +-
 doc/src/manual/faq.md             |  3 +--
 doc/src/manual/getting-started.md |  2 +-
 6 files changed, 22 insertions(+), 18 deletions(-)

diff --git a/README.md b/README.md
index 021322336d286..0ed6ed9117434 100644
--- a/README.md
+++ b/README.md
@@ -43,7 +43,7 @@ and installing Julia, below.
 ## Resources
 
 - **Homepage:** <https://julialang.org>
-- **Binaries:** <https://julialang.org/downloads/>
+- **Install:** <https://julialang.org/install/>
 - **Source code:** <https://github.com/JuliaLang/julia>
 - **Documentation:** <https://docs.julialang.org>
 - **Packages:** <https://julialang.org/packages/>
@@ -63,17 +63,22 @@ helpful to start contributing to the Julia codebase.
 
 ## Binary Installation
 
-If you would rather not compile the latest Julia from source,
-platform-specific tarballs with pre-compiled binaries are also
-[available for download](https://julialang.org/downloads/). The
-downloads page also provides details on the
-[different tiers of support](https://julialang.org/downloads/#supported_platforms)
-for OS and platform combinations.
-
-If everything works correctly, you will see a Julia banner and an
-interactive prompt into which you can enter expressions for
-evaluation. You can read about [getting
-started](https://docs.julialang.org/en/v1/manual/getting-started/) in the manual.
+The recommended way of installing Julia is to use `juliaup` which will install
+the latest stable `julia` for you and help keep it up to date. It can also let
+you install and run different Julia versions simultaneously. Instructions for
+this can be find [here](https://julialang.org/install/). If you want to manually
+download specific Julia binaries, you can find those on the [downloads
+page](https://julialang.org/downloads/). The downloads page also provides
+details on the [different tiers of
+support](https://julialang.org/downloads/#supported_platforms) for OS and
+platform combinations.
+
+If everything works correctly, you will get a `julia` program and when you run
+it in a terminal or command prompt, you will see a Julia banner and an
+interactive prompt into which you can enter expressions for evaluation. You can
+read about [getting
+started](https://docs.julialang.org/en/v1/manual/getting-started/) in the
+manual.
 
 **Note**: Although some OS package managers provide Julia, such
 installations are neither maintained nor endorsed by the Julia
diff --git a/doc/man/julia.1 b/doc/man/julia.1
index 2da11ae1b3f18..9646464e1e63d 100644
--- a/doc/man/julia.1
+++ b/doc/man/julia.1
@@ -321,7 +321,7 @@ Website:  https://julialang.org/
 .br
 Documentation:  https://docs.julialang.org/
 .br
-Downloads:  https://julialang.org/downloads/
+Install:  https://julialang.org/install/
 
 .SH LICENSING
 Julia is an open-source project. It is made available under the MIT license.
diff --git a/doc/src/devdocs/build/windows.md b/doc/src/devdocs/build/windows.md
index ba4af459e24d0..fa7402ff95bb6 100644
--- a/doc/src/devdocs/build/windows.md
+++ b/doc/src/devdocs/build/windows.md
@@ -32,7 +32,7 @@ or edit `%USERPROFILE%\.gitconfig` and add/edit the lines:
 ## Binary distribution
 
 For the binary distribution installation notes on Windows please see the instructions at
-[https://julialang.org/downloads/platform/#windows](https://julialang.org/downloads/platform/#windows).
+[https://julialang.org/downloads/platform/#windows](https://julialang.org/downloads/platform/#windows). Note, however, that on all platforms [using `juliaup`](https://julialang.org/install/) is recommended over manually installing binaries.
 
 ## Source distribution
 
diff --git a/doc/src/index.md b/doc/src/index.md
index 8c88af424e8e3..8342ff448625d 100644
--- a/doc/src/index.md
+++ b/doc/src/index.md
@@ -37,7 +37,7 @@ Markdown.parse("""
 Below is a non-exhaustive list of links that will be useful as you learn and use the Julia programming language.
 
 - [Julia Homepage](https://julialang.org)
-- [Download Julia](https://julialang.org/downloads/)
+- [Install Julia](https://julialang.org/install/)
 - [Discussion forum](https://discourse.julialang.org)
 - [Julia YouTube](https://www.youtube.com/user/JuliaLanguage)
 - [Find Julia Packages](https://julialang.org/packages/)
diff --git a/doc/src/manual/faq.md b/doc/src/manual/faq.md
index be4f331cd6233..188b8b7f79f3a 100644
--- a/doc/src/manual/faq.md
+++ b/doc/src/manual/faq.md
@@ -1090,8 +1090,7 @@ You may wish to test against the nightly version to ensure that such regressions
 Finally, you may also consider building Julia from source for yourself. This option is mainly for those individuals who are comfortable at the command line, or interested in learning.
 If this describes you, you may also be interested in reading our [guidelines for contributing](https://github.com/JuliaLang/julia/blob/master/CONTRIBUTING.md).
 
-Links to each of these download types can be found on the download page at [https://julialang.org/downloads/](https://julialang.org/downloads/).
-Note that not all versions of Julia are available for all platforms.
+The [`juliaup` install manager](https://julialang.org/install/) has pre-defined channels named `release` and `lts` for the latest stable release and the current LTS release, as well as version-specific channels.
 
 ### How can I transfer the list of installed packages after updating my version of Julia?
 
diff --git a/doc/src/manual/getting-started.md b/doc/src/manual/getting-started.md
index 2c69aabbda192..b0299a4563f98 100644
--- a/doc/src/manual/getting-started.md
+++ b/doc/src/manual/getting-started.md
@@ -1,7 +1,7 @@
 # [Getting Started](@id man-getting-started)
 
 Julia installation is straightforward, whether using precompiled binaries or compiling from source.
-Download and install Julia by following the instructions at [https://julialang.org/downloads/](https://julialang.org/downloads/).
+Download and install Julia by following the instructions at [https://julialang.org/install/](https://julialang.org/install/).
 
 If you are coming to Julia from one of the following languages, then you should start by reading the section on noteworthy differences from [MATLAB](@ref Noteworthy-differences-from-MATLAB), [R](@ref Noteworthy-differences-from-R), [Python](@ref Noteworthy-differences-from-Python), [C/C++](@ref Noteworthy-differences-from-C/C) or [Common Lisp](@ref Noteworthy-differences-from-Common-Lisp). This will help you avoid some common pitfalls since Julia differs from those languages in many subtle ways.
 

From 9d454dc5fb5b9491d13fef2d2723f361f10903ef Mon Sep 17 00:00:00 2001
From: Tim Holy <tim.holy@gmail.com>
Date: Wed, 16 Apr 2025 08:11:10 -0500
Subject: [PATCH 22/38] Ensure completion of invalidation log (#58137)

(cherry picked from commit caa97c91ec998ebfc09c2589a85998c0a0c7bb97)
---
 src/gf.c       |  5 +++--
 test/worlds.jl | 21 +++++++++++++++++++++
 2 files changed, 24 insertions(+), 2 deletions(-)

diff --git a/src/gf.c b/src/gf.c
index d964c4c18cb51..bacd72f89330b 100644
--- a/src/gf.c
+++ b/src/gf.c
@@ -2445,13 +2445,14 @@ void jl_method_table_activate(jl_methtable_t *mt, jl_typemap_entry_t *newentry)
                         // found that this specialization dispatch got replaced by m
                         // call invalidate_backedges(mi, max_world, "jl_method_table_insert");
                         // but ignore invoke-type edges
-                        invalidated = _invalidate_dispatch_backedges(mi, type, m, d, n, replaced_dispatch, ambig, max_world, morespec);
+                        int invalidatedmi = _invalidate_dispatch_backedges(mi, type, m, d, n, replaced_dispatch, ambig, max_world, morespec);
                         jl_array_ptr_1d_push(oldmi, (jl_value_t*)mi);
-                        if (_jl_debug_method_invalidation && invalidated) {
+                        if (_jl_debug_method_invalidation && invalidatedmi) {
                             jl_array_ptr_1d_push(_jl_debug_method_invalidation, (jl_value_t*)mi);
                             loctag = jl_cstr_to_string("jl_method_table_insert");
                             jl_array_ptr_1d_push(_jl_debug_method_invalidation, loctag);
                         }
+                        invalidated |= invalidatedmi;
                     }
                 }
             }
diff --git a/test/worlds.jl b/test/worlds.jl
index 4520ab257d078..dd98170721b1a 100644
--- a/test/worlds.jl
+++ b/test/worlds.jl
@@ -420,6 +420,27 @@ ccall(:jl_debug_method_invalidation, Any, (Cint,), 0)
     "jl_method_table_insert"
 ]
 
+# logging issue #58080
+f58080(::Integer) = 1
+callsf58080rts(x) = f58080(Base.inferencebarrier(x)::Signed)
+invokesf58080s(x) = invoke(f58080, Tuple{Signed}, x)
+# compilation
+invokesf58080s(1)                        # invoked callee
+callsf58080rts(1)                        # runtime-dispatched callee
+# invalidation
+logmeths = ccall(:jl_debug_method_invalidation, Any, (Cint,), 1);
+f58080(::Int) = 2
+f58080(::Signed) = 4
+ccall(:jl_debug_method_invalidation, Any, (Cint,), 0);
+@test logmeths[1].def.name === :callsf58080rts
+m58080i = which(f58080, (Int,))
+m58080s = which(f58080, (Signed,))
+idxi = findfirst(==(m58080i), logmeths)
+@test logmeths[idxi+1] == "jl_method_table_insert"
+@test logmeths[idxi+2].def.name === :invokesf58080s
+@test logmeths[end-1] == m58080s
+@test logmeths[end] == "jl_method_table_insert"
+
 # issue #50091 -- missing invoke edge affecting nospecialized dispatch
 module ExceptionUnwrapping
 @nospecialize

From 640c4e1b5fd11c3b485c6982a90c06cd65cc9717 Mon Sep 17 00:00:00 2001
From: Kiran Pamnany <kpamnany@users.noreply.github.com>
Date: Thu, 27 Mar 2025 11:10:05 -0400
Subject: [PATCH 23/38] Scheduler: Use a "scheduler" task for thread sleep
 (#57544)

A Julia thread runs Julia's scheduler in the context of the switching
task. If no task is found to switch to, the thread will sleep while
holding onto the (possibly completed) task, preventing the task from
being garbage collected. This recent [Discourse
post](https://discourse.julialang.org/t/weird-behaviour-of-gc-with-multithreaded-array-access/125433)
illustrates precisely this problem.

A solution to this would be for an idle Julia thread to switch to a
"scheduler" task, thereby freeing the old task.

This PR uses `OncePerThread` to create a "scheduler" task (that does
nothing but run `wait()` in a loop) and switches to that task when the
thread finds itself idle.

Other approaches considered and discarded in favor of this one:
https://github.com/JuliaLang/julia/pull/57465 and
https://github.com/JuliaLang/julia/pull/57543.

(cherry picked from commit 0d4d6d927d531c82e454e5a08c4bf6802cf69001)
---
 base/task.jl                    | 50 ++++++++++++++++++++++++---------
 stdlib/Sockets/test/runtests.jl |  4 +--
 test/channels.jl                |  5 ++--
 3 files changed, 40 insertions(+), 19 deletions(-)

diff --git a/base/task.jl b/base/task.jl
index 951e980ee903c..8cfb959536b2a 100644
--- a/base/task.jl
+++ b/base/task.jl
@@ -1145,6 +1145,16 @@ function throwto(t::Task, @nospecialize exc)
     return try_yieldto(identity)
 end
 
+@inline function wait_forever()
+    while true
+        wait()
+    end
+end
+
+const get_sched_task = OncePerThread{Task}() do
+    @task wait_forever()
+end
+
 function ensure_rescheduled(othertask::Task)
     ct = current_task()
     W = workqueue_for(Threads.threadid())
@@ -1181,25 +1191,39 @@ end
 
 checktaskempty = Partr.multiq_check_empty
 
-@noinline function poptask(W::StickyWorkqueue)
-    task = trypoptask(W)
-    if !(task isa Task)
-        task = ccall(:jl_task_get_next, Ref{Task}, (Any, Any, Any), trypoptask, W, checktaskempty)
-    end
-    set_next_task(task)
-    nothing
-end
-
 function wait()
     ct = current_task()
     # [task] user_time -yield-or-done-> wait_time
     record_running_time!(ct)
+    # let GC run
     GC.safepoint()
-    W = workqueue_for(Threads.threadid())
-    poptask(W)
-    result = try_yieldto(ensure_rescheduled)
+    # check for libuv events
     process_events()
-    # return when we come out of the queue
+
+    # get the next task to run
+    result = nothing
+    have_result = false
+    W = workqueue_for(Threads.threadid())
+    task = trypoptask(W)
+    if !(task isa Task)
+        # No tasks to run; switch to the scheduler task to run the
+        # thread sleep logic.
+        sched_task = get_sched_task()
+        if ct !== sched_task
+            result = yieldto(sched_task)
+            have_result = true
+        else
+            task = ccall(:jl_task_get_next, Ref{Task}, (Any, Any, Any),
+                         trypoptask, W, checktaskempty)
+        end
+    end
+    # We may have already switched tasks (via the scheduler task), so
+    # only switch if we haven't.
+    if !have_result
+        @assert task isa Task
+        set_next_task(task)
+        result = try_yieldto(ensure_rescheduled)
+    end
     return result
 end
 
diff --git a/stdlib/Sockets/test/runtests.jl b/stdlib/Sockets/test/runtests.jl
index 26f95d4ce1819..5a822315ba2cd 100644
--- a/stdlib/Sockets/test/runtests.jl
+++ b/stdlib/Sockets/test/runtests.jl
@@ -547,14 +547,12 @@ end
         fetch(r)
     end
 
-    let addr = Sockets.InetAddr(ip"127.0.0.1", 4444)
-        srv = listen(addr)
+    let addr = Sockets.InetAddr(ip"192.0.2.5", 4444)
         s = Sockets.TCPSocket()
         Sockets.connect!(s, addr)
         r = @async close(s)
         @test_throws Base._UVError("connect", Base.UV_ECANCELED) Sockets.wait_connected(s)
         fetch(r)
-        close(srv)
     end
 end
 
diff --git a/test/channels.jl b/test/channels.jl
index f646b41cfa1a0..721eb478bd13a 100644
--- a/test/channels.jl
+++ b/test/channels.jl
@@ -463,15 +463,14 @@ end
         cb = first(async.cond.waitq)
         @test isopen(async)
         ccall(:uv_async_send, Cvoid, (Ptr{Cvoid},), async)
-        ccall(:uv_async_send, Cvoid, (Ptr{Cvoid},), async)
-        @test isempty(Base.Workqueue)
         Base.process_events() # schedule event
         Sys.iswindows() && Base.process_events() # schedule event (windows?)
-        @test length(Base.Workqueue) == 1
         ccall(:uv_async_send, Cvoid, (Ptr{Cvoid},), async)
         @test tc[] == 0
         yield() # consume event
         @test tc[] == 1
+        ccall(:uv_async_send, Cvoid, (Ptr{Cvoid},), async)
+        Base.process_events()
         Sys.iswindows() && Base.process_events() # schedule event (windows?)
         yield() # consume event
         @test tc[] == 2

From a5bbb912c3c3d1d7f8687012785a37d35c17ea12 Mon Sep 17 00:00:00 2001
From: Jeff Bezanson <jeff.bezanson@gmail.com>
Date: Mon, 31 Mar 2025 03:58:55 -0400
Subject: [PATCH 24/38] fix trimming for scheduler task (#57926)

This unfortunately passed tests because it segfaults (sometimes) on
another thread while the main thread successfully executes. Soon we'll
have a general solution for tasks but this fixes it for now.

(cherry picked from commit df1b07ec4a5953df89f0c32f742d7a0b16111a70)
---
 base/task.jl                  | 2 +-
 contrib/juliac-buildscript.jl | 1 +
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/base/task.jl b/base/task.jl
index 8cfb959536b2a..e33a7e4efddf6 100644
--- a/base/task.jl
+++ b/base/task.jl
@@ -1152,7 +1152,7 @@ end
 end
 
 const get_sched_task = OncePerThread{Task}() do
-    @task wait_forever()
+    Task(wait_forever)
 end
 
 function ensure_rescheduled(othertask::Task)
diff --git a/contrib/juliac-buildscript.jl b/contrib/juliac-buildscript.jl
index 363330e4a3a79..0549afc0e1508 100644
--- a/contrib/juliac-buildscript.jl
+++ b/contrib/juliac-buildscript.jl
@@ -197,6 +197,7 @@ let mod = Base.include(Base.__toplevel__, inputfile)
     #entrypoint(join, (Base.GenericIOBuffer{Memory{UInt8}}, Array{String, 1}, Char))
     entrypoint(Base.task_done_hook, (Task,))
     entrypoint(Base.wait, ())
+    entrypoint(Base.wait_forever, ())
     entrypoint(Base.trypoptask, (Base.StickyWorkqueue,))
     entrypoint(Base.checktaskempty, ())
     if add_ccallables

From b3e1a0c4a62053d5fd322cd1376db00754625903 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Tue, 1 Apr 2025 16:20:23 -0400
Subject: [PATCH 25/38] batch some binding changes (#57765)

For model simplicity (and eventually for better unspecialized
compilation), try to backdate initial module operations back to world 0
if nobody could have observed them before (no using statements depend
on the module yet), rather than putting each incremental operation in a
separate, but unobserved (and unobservable) world increment.

(cherry picked from commit 3e063f6aa6dbc3eb5c15fed3323b6b8fa27896c4)
---
 base/Base_compiler.jl     |   7 +--
 base/sysimg.jl            |  19 ++-----
 doc/src/devdocs/init.md   |   2 +-
 src/builtins.c            |  10 ++--
 src/gf.c                  |   2 +-
 src/jl_exported_funcs.inc |   3 -
 src/jltypes.c             |   8 +--
 src/julia.h               |   5 +-
 src/julia_internal.h      |   8 +--
 src/module.c              |  60 +++++++++++++-------
 src/toplevel.c            | 112 ++++++++++++++++++++------------------
 11 files changed, 123 insertions(+), 113 deletions(-)

diff --git a/base/Base_compiler.jl b/base/Base_compiler.jl
index 986f2fbe6b05c..81660d17322e5 100644
--- a/base/Base_compiler.jl
+++ b/base/Base_compiler.jl
@@ -1,9 +1,8 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
 
-baremodule Base
+module Base
 
-using Core
-using Core.Intrinsics, Core.IR
+using .Core.Intrinsics, .Core.IR
 
 # to start, we're going to use a very simple definition of `include`
 # that doesn't require any function (except what we can get from the `Core` top-module)
@@ -381,5 +380,5 @@ Core._setparser!(fl_parse)
 
 # Further definition of Base will happen in Base.jl if loaded.
 
-end # baremodule Base
+end # module Base
 using .Base
diff --git a/base/sysimg.jl b/base/sysimg.jl
index c12ddcd71c66f..8adb05ece0b2c 100644
--- a/base/sysimg.jl
+++ b/base/sysimg.jl
@@ -1,19 +1,12 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
 
-# Can be loaded on top of either an existing system image built from
-# `Base_compiler.jl` or standalone, in which case we will build it now.
-let had_compiler = isdefined(Main, :Base)
-if had_compiler; else
-include("Base_compiler.jl")
-end
-
-Core.include(Base, "Base.jl")
+Base.Core.include(Base, "Base.jl") # finish populating Base (currently just has the Compiler)
 
-had_compiler && ccall(:jl_init_restored_module, Cvoid, (Any,), Base)
-end
+# Set up Main module by importing from Base
+using .Base
+using .Base.MainInclude # ans, err, and sometimes Out
 
-# Set up Main module
-using Base.MainInclude # ans, err, and sometimes Out
+ccall(:jl_init_restored_module, Cvoid, (Any,), Base)
 
 # These definitions calls Base._include rather than Base.include to get
 # one-frame stacktraces for the common case of using include(fname) in Main.
@@ -59,7 +52,7 @@ definition of `eval`, which evaluates expressions in that module.
 const eval = Core.EvalInto(Main)
 
 # Ensure this file is also tracked
-pushfirst!(Base._included_files, (@__MODULE__, abspath(@__FILE__)))
+pushfirst!(Base._included_files, (Main, abspath(@__FILE__)))
 
 # set up depot & load paths to be able to find stdlib packages
 Base.init_depot_path()
diff --git a/doc/src/devdocs/init.md b/doc/src/devdocs/init.md
index 1e0e1173f8695..23012d6ba1eb7 100644
--- a/doc/src/devdocs/init.md
+++ b/doc/src/devdocs/init.md
@@ -63,7 +63,7 @@ the [LLVM library](https://llvm.org).
 If there is no sysimg file (`!jl_options.image_file`) then the `Core` and `Main` modules are
 created and `boot.jl` is evaluated:
 
-`jl_core_module = jl_new_module(jl_symbol("Core"))` creates the Julia `Core` module.
+`jl_core_module = jl_new_module(jl_symbol("Core"), NULL)` creates the Julia `Core` module.
 
 [`jl_init_intrinsic_functions()`](https://github.com/JuliaLang/julia/blob/master/src/intrinsics.cpp)
 creates a new Julia module `Intrinsics` containing constant `jl_intrinsic_type` symbols. These define
diff --git a/src/builtins.c b/src/builtins.c
index 0f39c4783e4cd..a2cae857f26b4 100644
--- a/src/builtins.c
+++ b/src/builtins.c
@@ -2397,8 +2397,7 @@ static void add_intrinsic(jl_module_t *inm, const char *name, enum intrinsic f)
 {
     jl_value_t *i = jl_permbox32(jl_intrinsic_type, 0, (int32_t)f);
     jl_sym_t *sym = jl_symbol(name);
-    jl_set_const(inm, sym, i);
-    jl_module_public(inm, sym, 1);
+    jl_set_initial_const(inm, sym, i, 1);
 }
 
 void jl_init_intrinsic_properties(void) JL_GC_DISABLED
@@ -2414,9 +2413,8 @@ void jl_init_intrinsic_properties(void) JL_GC_DISABLED
 
 void jl_init_intrinsic_functions(void) JL_GC_DISABLED
 {
-    jl_module_t *inm = jl_new_module(jl_symbol("Intrinsics"), NULL);
-    inm->parent = jl_core_module;
-    jl_set_const(jl_core_module, jl_symbol("Intrinsics"), (jl_value_t*)inm);
+    jl_module_t *inm = jl_new_module_(jl_symbol("Intrinsics"), jl_core_module, 0, 1);
+    jl_set_initial_const(jl_core_module, jl_symbol("Intrinsics"), (jl_value_t*)inm, 0);
     jl_mk_builtin_func(jl_intrinsic_type, "IntrinsicFunction", jl_f_intrinsic_call);
     jl_mk_builtin_func(
         (jl_datatype_t*)jl_unwrap_unionall((jl_value_t*)jl_opaque_closure_type),
@@ -2438,7 +2436,7 @@ void jl_init_intrinsic_functions(void) JL_GC_DISABLED
 
 static void add_builtin(const char *name, jl_value_t *v)
 {
-    jl_set_const(jl_core_module, jl_symbol(name), v);
+    jl_set_initial_const(jl_core_module, jl_symbol(name), v, 0);
 }
 
 jl_fptr_args_t jl_get_builtin_fptr(jl_datatype_t *dt)
diff --git a/src/gf.c b/src/gf.c
index bacd72f89330b..209ca0827507f 100644
--- a/src/gf.c
+++ b/src/gf.c
@@ -294,7 +294,7 @@ jl_datatype_t *jl_mk_builtin_func(jl_datatype_t *dt, const char *name, jl_fptr_a
     if (dt == NULL) {
         // Builtins are specially considered available from world 0
         jl_value_t *f = jl_new_generic_function_with_supertype(sname, jl_core_module, jl_builtin_type, 0);
-        jl_set_const(jl_core_module, sname, f);
+        jl_set_initial_const(jl_core_module, sname, f, 0);
         dt = (jl_datatype_t*)jl_typeof(f);
     }
 
diff --git a/src/jl_exported_funcs.inc b/src/jl_exported_funcs.inc
index df1bdac23abe8..dfa4cf8ffe62c 100644
--- a/src/jl_exported_funcs.inc
+++ b/src/jl_exported_funcs.inc
@@ -2,7 +2,6 @@
 
 #define JL_RUNTIME_EXPORTED_FUNCS(XX) \
     XX(jl_active_task_stack) \
-    XX(jl_add_standard_imports) \
     XX(jl_adopt_thread) \
     XX(jl_alignment) \
     XX(jl_alloc_array_1d) \
@@ -97,7 +96,6 @@
     XX(jl_cstr_to_string) \
     XX(jl_current_exception) \
     XX(jl_debug_method_invalidation) \
-    XX(jl_defines_or_exports_p) \
     XX(jl_deprecate_binding) \
     XX(jl_dlclose) \
     XX(jl_dlopen) \
@@ -314,7 +312,6 @@
     XX(jl_module_names) \
     XX(jl_module_parent) \
     XX(jl_module_getloc) \
-    XX(jl_module_public) \
     XX(jl_module_public_p) \
     XX(jl_module_use) \
     XX(jl_module_using) \
diff --git a/src/jltypes.c b/src/jltypes.c
index aa01bc07b11ad..78aa70e197b3b 100644
--- a/src/jltypes.c
+++ b/src/jltypes.c
@@ -3287,10 +3287,9 @@ void jl_init_types(void) JL_GC_DISABLED
                         jl_emptysvec, 0, 0, 3);
 
     core = jl_new_module(jl_symbol("Core"), NULL);
-    core->parent = core;
     jl_type_typename->mt->module = core;
     jl_core_module = core;
-    core = NULL; // not ready yet to use
+    core = NULL; // not actually ready yet to use
 
     tv = jl_svec1(tvar("Backend"));
     jl_addrspace_typename =
@@ -3381,9 +3380,8 @@ void jl_init_types(void) JL_GC_DISABLED
     core = jl_core_module;
     jl_atomic_store_relaxed(&core->bindingkeyset, (jl_genericmemory_t*)jl_an_empty_memory_any);
     // export own name, so "using Foo" makes "Foo" itself visible
-    jl_set_const(core, core->name, (jl_value_t*)core);
-    jl_module_public(core, core->name, 1);
-    jl_set_const(core, jl_symbol("CPU"), (jl_value_t*)cpumem);
+    jl_set_initial_const(core, core->name, (jl_value_t*)core, 1);
+    jl_set_initial_const(core, jl_symbol("CPU"), (jl_value_t*)cpumem, 0);
     core = NULL;
 
     jl_expr_type =
diff --git a/src/julia.h b/src/julia.h
index 6799558ef593d..954c39229da2b 100644
--- a/src/julia.h
+++ b/src/julia.h
@@ -2109,13 +2109,13 @@ JL_DLLEXPORT void jl_check_binding_currently_writable(jl_binding_t *b, jl_module
 JL_DLLEXPORT jl_binding_t *jl_get_binding_wr(jl_module_t *m JL_PROPAGATES_ROOT, jl_sym_t *var);
 JL_DLLEXPORT jl_value_t *jl_get_existing_strong_gf(jl_binding_t *b JL_PROPAGATES_ROOT, size_t new_world);
 JL_DLLEXPORT int jl_boundp(jl_module_t *m, jl_sym_t *var, int allow_import);
-JL_DLLEXPORT int jl_defines_or_exports_p(jl_module_t *m, jl_sym_t *var);
 JL_DLLEXPORT int jl_is_const(jl_module_t *m, jl_sym_t *var);
 JL_DLLEXPORT int jl_globalref_is_const(jl_globalref_t *gr);
 JL_DLLEXPORT jl_value_t *jl_get_globalref_value(jl_globalref_t *gr);
 JL_DLLEXPORT jl_value_t *jl_get_global(jl_module_t *m JL_PROPAGATES_ROOT, jl_sym_t *var);
 JL_DLLEXPORT void jl_set_global(jl_module_t *m JL_ROOTING_ARGUMENT, jl_sym_t *var, jl_value_t *val JL_ROOTED_ARGUMENT);
 JL_DLLEXPORT void jl_set_const(jl_module_t *m JL_ROOTING_ARGUMENT, jl_sym_t *var, jl_value_t *val JL_ROOTED_ARGUMENT);
+void jl_set_initial_const(jl_module_t *m JL_ROOTING_ARGUMENT, jl_sym_t *var, jl_value_t *val JL_ROOTED_ARGUMENT, int exported);
 JL_DLLEXPORT void jl_checked_assignment(jl_binding_t *b, jl_module_t *mod, jl_sym_t *var, jl_value_t *rhs JL_MAYBE_UNROOTED);
 JL_DLLEXPORT jl_value_t *jl_checked_swap(jl_binding_t *b, jl_module_t *mod, jl_sym_t *var, jl_value_t *rhs JL_MAYBE_UNROOTED);
 JL_DLLEXPORT jl_value_t *jl_checked_replace(jl_binding_t *b, jl_module_t *mod, jl_sym_t *var, jl_value_t *expected, jl_value_t *rhs);
@@ -2128,10 +2128,9 @@ JL_DLLEXPORT void jl_module_use(jl_task_t *ct, jl_module_t *to, jl_module_t *fro
 JL_DLLEXPORT void jl_module_use_as(jl_task_t *ct, jl_module_t *to, jl_module_t *from, jl_sym_t *s, jl_sym_t *asname);
 JL_DLLEXPORT void jl_module_import(jl_task_t *ct, jl_module_t *to, jl_module_t *from, jl_sym_t *s);
 JL_DLLEXPORT void jl_module_import_as(jl_task_t *ct, jl_module_t *to, jl_module_t *from, jl_sym_t *s, jl_sym_t *asname);
-JL_DLLEXPORT void jl_module_public(jl_module_t *from, jl_sym_t *s, int exported);
+int jl_module_public_(jl_module_t *from, jl_sym_t *s, int exported, size_t new_world);
 JL_DLLEXPORT int jl_is_imported(jl_module_t *m, jl_sym_t *s);
 JL_DLLEXPORT int jl_module_exports_p(jl_module_t *m, jl_sym_t *var);
-JL_DLLEXPORT void jl_add_standard_imports(jl_module_t *m);
 
 // eq hash tables
 JL_DLLEXPORT jl_genericmemory_t *jl_eqtable_put(jl_genericmemory_t *h JL_ROOTING_ARGUMENT, jl_value_t *key, jl_value_t *val JL_ROOTED_ARGUMENT, int *inserted);
diff --git a/src/julia_internal.h b/src/julia_internal.h
index 4ab128da128d2..3e93df73bccfe 100644
--- a/src/julia_internal.h
+++ b/src/julia_internal.h
@@ -869,6 +869,7 @@ JL_DLLEXPORT void jl_declare_global(jl_module_t *m, jl_value_t *arg, jl_value_t
 JL_DLLEXPORT jl_binding_partition_t *jl_declare_constant_val3(jl_binding_t *b JL_ROOTING_ARGUMENT, jl_module_t *mod, jl_sym_t *var, jl_value_t *val JL_ROOTED_ARGUMENT JL_MAYBE_UNROOTED, enum jl_partition_kind, size_t new_world) JL_GLOBALLY_ROOTED;
 JL_DLLEXPORT jl_value_t *jl_toplevel_eval_flex(jl_module_t *m, jl_value_t *e, int fast, int expanded, const char **toplevel_filename, int *toplevel_lineno);
 
+void jl_module_initial_using(jl_module_t *to, jl_module_t *from);
 STATIC_INLINE struct _jl_module_using *module_usings_getidx(jl_module_t *m JL_PROPAGATES_ROOT, size_t i) JL_NOTSAFEPOINT;
 STATIC_INLINE jl_module_t *module_usings_getmod(jl_module_t *m JL_PROPAGATES_ROOT, size_t i) JL_NOTSAFEPOINT;
 void jl_add_usings_backedge(jl_module_t *from, jl_module_t *to);
@@ -941,7 +942,7 @@ JL_DLLEXPORT jl_binding_partition_t *jl_replace_binding_locked2(jl_binding_t *b
 JL_DLLEXPORT void jl_update_loaded_bpart(jl_binding_t *b, jl_binding_partition_t *bpart);
 extern jl_array_t *jl_module_init_order JL_GLOBALLY_ROOTED;
 extern htable_t jl_current_modules JL_GLOBALLY_ROOTED;
-extern JL_DLLEXPORT jl_module_t *jl_precompile_toplevel_module JL_GLOBALLY_ROOTED;
+extern jl_module_t *jl_precompile_toplevel_module JL_GLOBALLY_ROOTED;
 extern jl_genericmemory_t *jl_global_roots_list JL_GLOBALLY_ROOTED;
 extern jl_genericmemory_t *jl_global_roots_keyset JL_GLOBALLY_ROOTED;
 extern arraylist_t *jl_entrypoint_mis;
@@ -1275,9 +1276,8 @@ _Atomic(jl_value_t*) *jl_table_peek_bp(jl_genericmemory_t *a, jl_value_t *key) J
 
 JL_DLLEXPORT jl_method_t *jl_new_method_uninit(jl_module_t*);
 
-JL_DLLEXPORT jl_module_t *jl_new_module__(jl_sym_t *name, jl_module_t *parent);
-JL_DLLEXPORT jl_module_t *jl_new_module_(jl_sym_t *name, jl_module_t *parent, uint8_t default_using_core, uint8_t self_name);
-JL_DLLEXPORT void jl_add_default_names(jl_module_t *m, uint8_t default_using_core, uint8_t self_name);
+jl_module_t *jl_new_module_(jl_sym_t *name, jl_module_t *parent, uint8_t default_using_core, uint8_t self_name);
+jl_module_t *jl_add_standard_imports(jl_module_t *m);
 JL_DLLEXPORT jl_methtable_t *jl_new_method_table(jl_sym_t *name, jl_module_t *module);
 JL_DLLEXPORT jl_method_instance_t *jl_get_specialization1(jl_tupletype_t *types JL_PROPAGATES_ROOT, size_t world, int mt_cache);
 jl_method_instance_t *jl_get_specialized(jl_method_t *m, jl_value_t *types, jl_svec_t *sp) JL_PROPAGATES_ROOT;
diff --git a/src/module.c b/src/module.c
index 1f20352b0ec30..7cd0ae4492eeb 100644
--- a/src/module.c
+++ b/src/module.c
@@ -401,7 +401,7 @@ JL_DLLEXPORT jl_value_t *jl_get_binding_leaf_partitions_value_if_const(jl_bindin
     return NULL;
 }
 
-JL_DLLEXPORT jl_module_t *jl_new_module__(jl_sym_t *name, jl_module_t *parent)
+static jl_module_t *jl_new_module__(jl_sym_t *name, jl_module_t *parent)
 {
     jl_task_t *ct = jl_current_task;
     const jl_uuid_t uuid_zero = {0, 0};
@@ -410,7 +410,7 @@ JL_DLLEXPORT jl_module_t *jl_new_module__(jl_sym_t *name, jl_module_t *parent)
     jl_set_typetagof(m, jl_module_tag, 0);
     assert(jl_is_symbol(name));
     m->name = name;
-    m->parent = parent;
+    m->parent = parent ? parent : m;
     m->istopmod = 0;
     m->uuid = uuid_zero;
     static unsigned int mcounter; // simple counter backup, in case hrtime is not incrementing
@@ -437,23 +437,22 @@ JL_DLLEXPORT jl_module_t *jl_new_module__(jl_sym_t *name, jl_module_t *parent)
     return m;
 }
 
-JL_DLLEXPORT void jl_add_default_names(jl_module_t *m, uint8_t default_using_core, uint8_t self_name)
+static void jl_add_default_names(jl_module_t *m, uint8_t default_using_core, uint8_t self_name)
 {
     if (jl_core_module) {
         // Bootstrap: Before jl_core_module is defined, we don't have enough infrastructure
         // for bindings, so Core itself gets special handling in jltypes.c
         if (default_using_core) {
-            jl_module_using(m, jl_core_module);
+            jl_module_initial_using(m, jl_core_module);
         }
         if (self_name) {
             // export own name, so "using Foo" makes "Foo" itself visible
-            jl_set_const(m, m->name, (jl_value_t*)m);
-            jl_module_public(m, m->name, 1);
+            jl_set_initial_const(m, m->name, (jl_value_t*)m, 1);
         }
     }
 }
 
-JL_DLLEXPORT jl_module_t *jl_new_module_(jl_sym_t *name, jl_module_t *parent, uint8_t default_using_core, uint8_t self_name)
+jl_module_t *jl_new_module_(jl_sym_t *name, jl_module_t *parent, uint8_t default_using_core, uint8_t self_name)
 {
     jl_module_t *m = jl_new_module__(name, parent);
     JL_GC_PUSH1(&m);
@@ -1231,6 +1230,19 @@ void jl_add_usings_backedge(jl_module_t *from, jl_module_t *to)
     JL_UNLOCK(&from->lock);
 }
 
+void jl_module_initial_using(jl_module_t *to, jl_module_t *from)
+{
+    struct _jl_module_using new_item = {
+        .mod = from,
+        .min_world = 0,
+        .max_world = ~(size_t)0
+    };
+    arraylist_grow(&to->usings, sizeof(struct _jl_module_using)/sizeof(void*));
+    memcpy(&to->usings.items[to->usings.len-3], &new_item, sizeof(struct _jl_module_using));
+    jl_gc_wb(to, from);
+    jl_add_usings_backedge(from, to);
+}
+
 JL_DLLEXPORT void jl_module_using(jl_module_t *to, jl_module_t *from)
 {
     if (to == from)
@@ -1323,11 +1335,10 @@ JL_DLLEXPORT jl_value_t *jl_get_module_binding_or_nothing(jl_module_t *m, jl_sym
     return (jl_value_t*)b;
 }
 
-JL_DLLEXPORT void jl_module_public(jl_module_t *from, jl_sym_t *s, int exported)
+int jl_module_public_(jl_module_t *from, jl_sym_t *s, int exported, size_t new_world)
 {
+    // caller must hold world_counter_lock
     jl_binding_t *b = jl_get_module_binding(from, s, 1);
-    JL_LOCK(&world_counter_lock);
-    size_t new_world = jl_atomic_load_acquire(&jl_world_counter)+1;
     jl_binding_partition_t *bpart = jl_get_binding_partition(b, new_world);
     int was_exported = (bpart->kind & PARTITION_FLAG_EXPORTED) != 0;
     if (jl_atomic_load_relaxed(&b->flags) & BINDING_FLAG_PUBLICP) {
@@ -1342,9 +1353,9 @@ JL_DLLEXPORT void jl_module_public(jl_module_t *from, jl_sym_t *s, int exported)
     jl_atomic_fetch_or_relaxed(&b->flags, BINDING_FLAG_PUBLICP);
     if (was_exported != exported) {
         jl_replace_binding_locked2(b, bpart, bpart->restriction, bpart->kind | PARTITION_FLAG_EXPORTED, new_world);
-        jl_atomic_store_release(&jl_world_counter, new_world);
+        return 1;
     }
-    JL_UNLOCK(&world_counter_lock);
+    return 0;
 }
 
 JL_DLLEXPORT int jl_boundp(jl_module_t *m, jl_sym_t *var, int allow_import) // unlike most queries here, this is currently seq_cst
@@ -1370,13 +1381,6 @@ JL_DLLEXPORT int jl_boundp(jl_module_t *m, jl_sym_t *var, int allow_import) // u
     return jl_atomic_load(&b->value) != NULL;
 }
 
-JL_DLLEXPORT int jl_defines_or_exports_p(jl_module_t *m, jl_sym_t *var)
-{
-    jl_binding_t *b = jl_get_module_binding(m, var, 0);
-    jl_binding_partition_t *bpart = jl_get_binding_partition(b, jl_current_task->world_age);
-    return b && ((bpart->kind & PARTITION_FLAG_EXPORTED) || jl_binding_kind(bpart) == PARTITION_KIND_GLOBAL);
-}
-
 JL_DLLEXPORT int jl_module_exports_p(jl_module_t *m, jl_sym_t *var)
 {
     jl_binding_t *b = jl_get_module_binding(m, var, 0);
@@ -1475,9 +1479,25 @@ JL_DLLEXPORT void jl_set_global(jl_module_t *m JL_ROOTING_ARGUMENT, jl_sym_t *va
     jl_checked_assignment(bp, m, var, val);
 }
 
+JL_DLLEXPORT void jl_set_initial_const(jl_module_t *m JL_ROOTING_ARGUMENT, jl_sym_t *var, jl_value_t *val JL_ROOTED_ARGUMENT, int exported)
+{
+    // this function is only valid during initialization, so there is no risk of data races her are not too important to use
+    int kind = PARTITION_KIND_CONST | (exported ? PARTITION_FLAG_EXPORTED : 0);
+    // jl_declare_constant_val3(NULL, m, var, (jl_value_t*)jl_any_type, kind, 0);
+    jl_binding_t *bp = jl_get_module_binding(m, var, 1);
+    jl_binding_partition_t *bpart = jl_get_binding_partition(bp, 0);
+    assert(bpart->min_world == 0);
+    jl_atomic_store_relaxed(&bpart->max_world, ~(size_t)0); // jl_check_new_binding_implicit likely incorrectly truncated it
+    if (exported)
+        jl_atomic_fetch_or_relaxed(&bp->flags, BINDING_FLAG_PUBLICP);
+    bpart->kind = kind | (bpart->kind & PARTITION_MASK_FLAG);
+    bpart->restriction = val;
+    jl_gc_wb(bpart, val);
+}
+
 JL_DLLEXPORT void jl_set_const(jl_module_t *m JL_ROOTING_ARGUMENT, jl_sym_t *var, jl_value_t *val JL_ROOTED_ARGUMENT)
 {
-    // this function is mostly only used during initialization, so the data races here are not too important to us
+    // this function is dangerous and unsound. do not use.
     jl_binding_t *bp = jl_get_module_binding(m, var, 1);
     jl_binding_partition_t *bpart = jl_get_binding_partition(bp, jl_current_task->world_age);
     bpart->min_world = 0;
diff --git a/src/toplevel.c b/src/toplevel.c
index 174bb0ef4dd22..cbf220f0016f1 100644
--- a/src/toplevel.c
+++ b/src/toplevel.c
@@ -34,26 +34,24 @@ htable_t jl_current_modules;
 jl_mutex_t jl_modules_mutex;
 
 // During incremental compilation, the following gets set
-JL_DLLEXPORT jl_module_t *jl_precompile_toplevel_module = NULL;   // the toplevel module currently being defined
+jl_module_t *jl_precompile_toplevel_module = NULL;   // the toplevel module currently being defined
 
-JL_DLLEXPORT void jl_add_standard_imports(jl_module_t *m)
+jl_module_t *jl_add_standard_imports(jl_module_t *m)
 {
     jl_module_t *base_module = jl_base_relative_to(m);
     assert(base_module != NULL);
     // using Base
-    jl_module_using(m, base_module);
+    jl_module_initial_using(m, base_module);
+    return base_module;
 }
 
 // create a new top-level module
 void jl_init_main_module(void)
 {
     assert(jl_main_module == NULL);
-    jl_main_module = jl_new_module(jl_symbol("Main"), NULL);
-    jl_main_module->parent = jl_main_module;
-    jl_set_const(jl_main_module, jl_symbol("Core"),
-                 (jl_value_t*)jl_core_module);
-    jl_set_const(jl_core_module, jl_symbol("Main"),
-                 (jl_value_t*)jl_main_module);
+    jl_main_module = jl_new_module_(jl_symbol("Main"), NULL, 0, 1); // baremodule Main; end
+    jl_set_initial_const(jl_core_module, jl_symbol("Main"), (jl_value_t*)jl_main_module, 0); // const Main.Core = Core
+    jl_set_initial_const(jl_main_module, jl_symbol("Core"), (jl_value_t*)jl_core_module, 0); // const Core.Main = Main
 }
 
 static jl_function_t *jl_module_get_initializer(jl_module_t *m JL_PROPAGATES_ROOT)
@@ -138,38 +136,14 @@ static jl_value_t *jl_eval_module_expr(jl_module_t *parent_module, jl_expr_t *ex
     // If we have `Base`, don't also try to import `Core` - the `Base` exports are a superset.
     // While we allow multiple imports of the same binding from different modules, various error printing
     // performs reflection on which module a binding came from and we'd prefer users see "Base" here.
-    jl_module_t *newm = jl_new_module__(name, is_parent__toplevel__ ? NULL : parent_module);
+    jl_module_t *newm = jl_new_module_(name, is_parent__toplevel__ ? NULL : parent_module, std_imports && jl_base_module != NULL ? 0 : 1, 1);
     jl_value_t *form = (jl_value_t*)newm;
     JL_GC_PUSH1(&form);
     JL_LOCK(&jl_modules_mutex);
     ptrhash_put(&jl_current_modules, (void*)newm, (void*)((uintptr_t)HT_NOTFOUND + 1));
     JL_UNLOCK(&jl_modules_mutex);
-
-    jl_add_default_names(newm, std_imports && jl_base_module != NULL ? 0 : 1, 1);
-
-    jl_module_t *old_toplevel_module = jl_precompile_toplevel_module;
-
     // copy parent environment info into submodule
     newm->uuid = parent_module->uuid;
-    if (is_parent__toplevel__) {
-        newm->parent = newm;
-        jl_register_root_module(newm);
-        if (jl_options.incremental) {
-            jl_precompile_toplevel_module = newm;
-        }
-    }
-    else {
-        jl_declare_constant_val(NULL, parent_module, name, (jl_value_t*)newm);
-    }
-
-    if (parent_module == jl_main_module && name == jl_symbol("Base")) {
-        // pick up Base module during bootstrap
-        jl_base_module = newm;
-    }
-
-    size_t last_age = ct->world_age;
-
-    // add standard imports unless baremodule
     jl_array_t *exprs = ((jl_expr_t*)jl_exprarg(ex, 2))->args;
     int lineno = 0;
     const char *filename = "none";
@@ -182,25 +156,42 @@ static jl_value_t *jl_eval_module_expr(jl_module_t *parent_module, jl_expr_t *ex
                 filename = jl_symbol_name((jl_sym_t*)file);
         }
     }
-    if (std_imports) {
-        if (jl_base_module != NULL) {
-            jl_add_standard_imports(newm);
-            jl_datatype_t *include_into = (jl_datatype_t *)jl_get_global(jl_base_module, jl_symbol("IncludeInto"));
-            if (include_into) {
-                form = jl_new_struct(include_into, newm);
-                jl_set_const(newm, jl_symbol("include"), form);
-            }
+    newm->file = jl_symbol(filename);
+    jl_gc_wb_knownold(newm, newm->file);
+    newm->line = lineno;
+
+    // add standard imports unless baremodule
+    if (std_imports && jl_base_module != NULL) {
+        jl_module_t *base = jl_add_standard_imports(newm);
+        jl_datatype_t *include_into = (jl_datatype_t *)jl_get_global(base, jl_symbol("IncludeInto"));
+        if (include_into) {
+            form = jl_new_struct(include_into, newm);
+            jl_set_initial_const(newm, jl_symbol("include"), form, 0);
         }
         jl_datatype_t *eval_into = (jl_datatype_t *)jl_get_global(jl_core_module, jl_symbol("EvalInto"));
         if (eval_into) {
             form = jl_new_struct(eval_into, newm);
-            jl_set_const(newm, jl_symbol("eval"), form);
+            jl_set_initial_const(newm, jl_symbol("eval"), form, 0);
         }
     }
 
-    newm->file = jl_symbol(filename);
-    jl_gc_wb_knownold(newm, newm->file);
-    newm->line = lineno;
+    jl_module_t *old_toplevel_module = jl_precompile_toplevel_module;
+    size_t last_age = ct->world_age;
+
+    if (parent_module == jl_main_module && name == jl_symbol("Base") && jl_base_module == NULL) {
+        // pick up Base module during bootstrap
+        jl_base_module = newm;
+    }
+
+    if (is_parent__toplevel__) {
+        jl_register_root_module(newm);
+        if (jl_options.incremental) {
+            jl_precompile_toplevel_module = newm;
+        }
+    }
+    else {
+        jl_declare_constant_val(NULL, parent_module, name, (jl_value_t*)newm);
+    }
 
     for (int i = 0; i < jl_array_nrows(exprs); i++) {
         // process toplevel form
@@ -934,14 +925,29 @@ JL_DLLEXPORT jl_value_t *jl_toplevel_eval_flex(jl_module_t *JL_NONNULL m, jl_val
     }
     else if (head == jl_export_sym || head == jl_public_sym) {
         int exp = (head == jl_export_sym);
-        for (size_t i = 0; i < jl_array_nrows(ex->args); i++) {
-            jl_sym_t *name = (jl_sym_t*)jl_array_ptr_ref(ex->args, i);
-            if (!jl_is_symbol(name))
-                jl_eval_errorf(m, *toplevel_filename, *toplevel_lineno,
-                     exp ? "syntax: malformed \"export\" statement" :
-                           "syntax: malformed \"public\" statement");
-            jl_module_public(m, name, exp);
+        volatile int any_new = 0;
+        JL_LOCK(&world_counter_lock);
+        size_t new_world = jl_atomic_load_acquire(&jl_world_counter)+1;
+        JL_TRY {
+            for (size_t i = 0; i < jl_array_nrows(ex->args); i++) {
+                jl_sym_t *name = (jl_sym_t*)jl_array_ptr_ref(ex->args, i);
+                if (!jl_is_symbol(name))
+                    jl_eval_errorf(m, *toplevel_filename, *toplevel_lineno,
+                         exp ? "syntax: malformed \"export\" statement" :
+                               "syntax: malformed \"public\" statement");
+                if (jl_module_public_(m, name, exp, new_world))
+                    any_new = 1;
+            }
+        }
+        JL_CATCH {
+            if (any_new)
+                jl_atomic_store_release(&jl_world_counter, new_world);
+            JL_UNLOCK(&world_counter_lock);
+            jl_rethrow();
         }
+        if (any_new)
+            jl_atomic_store_release(&jl_world_counter, new_world);
+        JL_UNLOCK(&world_counter_lock);
         JL_GC_POP();
         return jl_nothing;
     }

From 980347dc86b0295cc637e3c52dc13246ad97f50b Mon Sep 17 00:00:00 2001
From: Keno Fischer <keno@juliacomputing.com>
Date: Thu, 3 Apr 2025 21:10:04 -0400
Subject: [PATCH 26/38] Merge adjacent implicit binding partitions (#57995)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

After:
```
julia> convert(Core.Binding, GlobalRef(Base, :Intrinsics))
Binding Base.Intrinsics
   617:∞ - implicit `using` resolved to constant Core.Intrinsics
   0:616 - undefined binding - guard entry

julia> convert(Core.Binding, GlobalRef(Base, :Math))
Binding Base.Math
   22128:∞ - constant binding to Base.Math
   0:22127 - backdated constant binding to Base.Math
```

There is a bit of trickiness here. In particular, the question is, "when
do we check" whether the partition next to the one we currently looked
at happens to have the same implicit resolution as our current one. The
most obvious answer is that we should do it on access, but in practice
that would require essentially scanning back and considering every
possible world age state at every lookup. This is undesirable - the
lookup is not crazy expensive, but it can add up and most world ages we
never touch, so it is also wasteful.

This instead implements a different approach where we only perform the
resolution for world ages that somebody actually asked about, but can
then subsequently merge partitions if we do find that they are
identical. The logic for that is a bit involved, since we need to be
careful to keep the datastructure valid at every point, but does address
the issue.

Fixes #57923

(cherry picked from commit 1c3878c0740e9835ce604a5daca2c983e47e7389)
---
 src/jltypes.c     |   4 +-
 src/julia.h       |   6 +-
 src/module.c      | 138 ++++++++++++++++++++++++++++++++++------------
 src/rtutils.c     |   4 +-
 src/staticdata.c  |  12 ++--
 src/toplevel.c    |   4 +-
 test/rebinding.jl |  65 ++++++++++++++++++++++
 7 files changed, 186 insertions(+), 47 deletions(-)

diff --git a/src/jltypes.c b/src/jltypes.c
index 78aa70e197b3b..579da136ef4e9 100644
--- a/src/jltypes.c
+++ b/src/jltypes.c
@@ -3266,8 +3266,10 @@ void jl_init_types(void) JL_GC_DISABLED
                         jl_svec(5, jl_any_type,
                         jl_ulong_type, jl_ulong_type, jl_any_type/*jl_binding_partition_type*/, jl_ulong_type),
                         jl_emptysvec, 0, 1, 0);
-    const static uint32_t binding_partition_atomicfields[] = { 0b01101 }; // Set fields 1, 3, 4 as atomic
+    const static uint32_t binding_partition_atomicfields[] = { 0b01111 }; // Set fields 1, 2, 3, 4 as atomic
     jl_binding_partition_type->name->atomicfields = binding_partition_atomicfields;
+    const static uint32_t binding_partition_constfields[] = { 0x100001 }; // Set fields 1, 5 as constant
+    jl_binding_partition_type->name->constfields = binding_partition_constfields;
 
     jl_binding_type =
         jl_new_datatype(jl_symbol("Binding"), core, jl_any_type, jl_emptysvec,
diff --git a/src/julia.h b/src/julia.h
index 954c39229da2b..d8496a9304ccd 100644
--- a/src/julia.h
+++ b/src/julia.h
@@ -760,7 +760,7 @@ typedef struct JL_ALIGNED_ATTR(8) _jl_binding_partition_t {
      * } restriction;
      */
     jl_value_t *restriction;
-    size_t min_world;
+    _Atomic(size_t) min_world;
     _Atomic(size_t) max_world;
     _Atomic(struct _jl_binding_partition_t *) next;
     size_t kind;
@@ -1955,8 +1955,8 @@ JL_DLLEXPORT jl_sym_t *jl_get_root_symbol(void);
 JL_DLLEXPORT jl_value_t *jl_get_binding_value(jl_binding_t *b JL_PROPAGATES_ROOT);
 JL_DLLEXPORT jl_value_t *jl_get_binding_value_in_world(jl_binding_t *b JL_PROPAGATES_ROOT, size_t world);
 JL_DLLEXPORT jl_value_t *jl_get_binding_value_if_const(jl_binding_t *b JL_PROPAGATES_ROOT);
-JL_DLLEXPORT jl_value_t *jl_get_binding_value_if_resolved(jl_binding_t *b JL_PROPAGATES_ROOT) JL_NOTSAFEPOINT;
-JL_DLLEXPORT jl_value_t *jl_get_binding_value_if_resolved_and_const(jl_binding_t *b JL_PROPAGATES_ROOT) JL_NOTSAFEPOINT;
+JL_DLLEXPORT jl_value_t *jl_get_binding_value_if_resolved_debug_only(jl_binding_t *b JL_PROPAGATES_ROOT) JL_NOTSAFEPOINT;
+JL_DLLEXPORT jl_value_t *jl_get_binding_value_if_latest_resolved_and_const_debug_only(jl_binding_t *b JL_PROPAGATES_ROOT) JL_NOTSAFEPOINT;
 JL_DLLEXPORT jl_value_t *jl_declare_const_gf(jl_module_t *mod, jl_sym_t *name);
 JL_DLLEXPORT jl_method_t *jl_method_def(jl_svec_t *argdata, jl_methtable_t *mt, jl_code_info_t *f, jl_module_t *module);
 JL_DLLEXPORT jl_code_info_t *jl_code_for_staged(jl_method_instance_t *linfo, size_t world, jl_code_instance_t **cache);
diff --git a/src/module.c b/src/module.c
index 7cd0ae4492eeb..54df487bcef22 100644
--- a/src/module.c
+++ b/src/module.c
@@ -20,7 +20,7 @@ static jl_binding_partition_t *new_binding_partition(void)
     jl_binding_partition_t *bpart = (jl_binding_partition_t*)jl_gc_alloc(jl_current_task->ptls, sizeof(jl_binding_partition_t), jl_binding_partition_type);
     bpart->restriction = NULL;
     bpart->kind = (size_t)PARTITION_KIND_GUARD;
-    bpart->min_world = 0;
+    jl_atomic_store_relaxed(&bpart->min_world, 0);
     jl_atomic_store_relaxed(&bpart->max_world, (size_t)-1);
     jl_atomic_store_relaxed(&bpart->next, NULL);
     return bpart;
@@ -40,9 +40,12 @@ STATIC_INLINE jl_binding_partition_t *jl_get_binding_partition__(jl_binding_t *b
 {
     // Iterate through the list of binding partitions, keeping track of where to insert a new one for an implicit
     // resolution if necessary.
-    while (gap->replace && world < gap->replace->min_world) {
+    while (gap->replace) {
+        size_t replace_min_world = jl_atomic_load_relaxed(&gap->replace->min_world);
+        if (world >= replace_min_world)
+            break;
         gap->insert = &gap->replace->next;
-        gap->max_world = gap->replace->min_world - 1;
+        gap->max_world = replace_min_world - 1;
         gap->parent = (jl_value_t*)gap->replace;
         gap->replace = jl_atomic_load_relaxed(gap->insert);
     }
@@ -126,13 +129,70 @@ static void update_implicit_resolution(struct implicit_search_resolution *to_upd
 
 static jl_binding_partition_t *jl_implicit_import_resolved(jl_binding_t *b, struct implicit_search_gap gap, struct implicit_search_resolution resolution)
 {
+    size_t new_kind = resolution.ultimate_kind | gap.inherited_flags;
+    size_t new_max_world = gap.max_world < resolution.max_world ? gap.max_world : resolution.max_world;
+    size_t new_min_world = gap.min_world > resolution.min_world ? gap.min_world : resolution.min_world;
+    jl_binding_partition_t *next = gap.replace;
+    if (jl_is_binding_partition(gap.parent)) {
+        // Check if we can merge this into the previous binding partition
+        jl_binding_partition_t *prev = (jl_binding_partition_t *)gap.parent;
+        size_t expected_prev_min_world = new_max_world + 1;
+        if (prev->restriction == resolution.binding_or_const && prev->kind == new_kind) {
+            if (!jl_atomic_cmpswap(&prev->min_world, &expected_prev_min_world, new_min_world)) {
+                if (expected_prev_min_world <= new_min_world) {
+                    return prev;
+                }
+                else if (expected_prev_min_world <= new_max_world) {
+                    // Concurrent modification by another thread - bail.
+                    return NULL;
+                }
+                // There remains a gap - proceed
+            } else {
+                if (next) {
+                    size_t next_min_world = jl_atomic_load_relaxed(&next->min_world);
+                    expected_prev_min_world = new_min_world;
+                    for (;;) {
+                        // We've updated the previous partition - check if we've closed a gap
+                        size_t next_max_world = jl_atomic_load_relaxed(&next->max_world);
+                        if (next_max_world == expected_prev_min_world-1 && next->kind == new_kind && next->restriction == resolution.binding_or_const) {
+                            if (jl_atomic_cmpswap(&prev->min_world, &expected_prev_min_world, next_min_world)) {
+                                jl_binding_partition_t *nextnext = jl_atomic_load_relaxed(&next->next);
+                                if (!jl_atomic_cmpswap(&prev->next, &next, nextnext)) {
+                                    // `next` may have been merged into its subsequent partition - we need to retry
+                                    assert(next);
+                                    continue;
+                                }
+                                // N.B.: This can lose modifications to next->{min_world, next}.
+                                // However, those modifications could only have been for another implicit
+                                // partition, so we are ok to lose them and recompute them later if necessary.
+                            }
+                            assert(expected_prev_min_world <= new_min_world);
+                        }
+                        break;
+                    }
+                }
+                return prev;
+            }
+        }
+    }
     jl_binding_partition_t *new_bpart = new_binding_partition();
-    jl_atomic_store_relaxed(&new_bpart->max_world, gap.max_world < resolution.max_world ? gap.max_world : resolution.max_world);
-    new_bpart->min_world = gap.min_world > resolution.min_world ? gap.min_world : resolution.min_world;
-    new_bpart->kind = resolution.ultimate_kind | gap.inherited_flags;
+    jl_atomic_store_relaxed(&new_bpart->max_world, new_max_world);
+    new_bpart->kind = new_kind;
     new_bpart->restriction = resolution.binding_or_const;
     jl_gc_wb_fresh(new_bpart, new_bpart->restriction);
-    jl_atomic_store_relaxed(&new_bpart->next, gap.replace);
+
+    if (next) {
+        // See if we can merge the next partition into this one
+        size_t next_max_world = jl_atomic_load_relaxed(&next->max_world);
+        if (next_max_world == new_min_world - 1 && next->kind == new_kind && next->restriction == resolution.binding_or_const) {
+            // See above for potentially losing modifications to next.
+            new_min_world = jl_atomic_load_acquire(&next->min_world);
+            next = jl_atomic_load_relaxed(&next->next);
+        }
+    }
+
+    jl_atomic_store_relaxed(&new_bpart->min_world, new_min_world);
+    jl_atomic_store_relaxed(&new_bpart->next, next);
     if (!jl_atomic_cmpswap(gap.insert, &gap.replace, new_bpart))
         return NULL;
     jl_gc_wb(gap.parent, new_bpart);
@@ -170,13 +230,11 @@ struct implicit_search_resolution jl_resolve_implicit_import(jl_binding_t *b, mo
         struct _jl_module_using data = *module_usings_getidx(m, i);
         JL_UNLOCK(&m->lock);
         if (data.min_world > world) {
-            if (max_world > data.min_world)
-                max_world = data.min_world - 1;
+            max_world = WORLDMIN(max_world, data.min_world - 1);
             continue;
         }
         if (data.max_world < world) {
-            if (min_world < data.max_world)
-                min_world = data.max_world + 1;
+            min_world = WORLDMAX(min_world, data.max_world + 1);
             continue;
         }
 
@@ -198,7 +256,7 @@ struct implicit_search_resolution jl_resolve_implicit_import(jl_binding_t *b, mo
 
         while (tempbpart && jl_bkind_is_some_explicit_import(jl_binding_kind(tempbpart))) {
             max_world = WORLDMIN(max_world, jl_atomic_load_relaxed(&tempbpart->max_world));
-            min_world = WORLDMAX(min_world, tempbpart->min_world);
+            min_world = WORLDMAX(min_world, jl_atomic_load_relaxed(&tempbpart->min_world));
 
             tempb = (jl_binding_t*)tempbpart->restriction;
             tempbpart = jl_get_binding_partition_if_present(tempb, world, &gap);
@@ -206,7 +264,7 @@ struct implicit_search_resolution jl_resolve_implicit_import(jl_binding_t *b, mo
 
         int tempbpart_valid = tempbpart && (trust_cache || !jl_bkind_is_some_implicit(jl_binding_kind(tempbpart)));
         size_t tembppart_max_world = tempbpart_valid ? jl_atomic_load_relaxed(&tempbpart->max_world) : gap.max_world;
-        size_t tembppart_min_world = tempbpart ? WORLDMAX(tempbpart->min_world, gap.min_world) : gap.min_world;
+        size_t tembppart_min_world = tempbpart ? WORLDMAX(jl_atomic_load_relaxed(&tempbpart->min_world), gap.min_world) : gap.min_world;
 
         max_world = WORLDMIN(max_world, tembppart_max_world);
         min_world = WORLDMAX(min_world, tembppart_min_world);
@@ -279,8 +337,15 @@ JL_DLLEXPORT jl_binding_partition_t *jl_maybe_reresolve_implicit(jl_binding_t *b
         assert(bpart == jl_atomic_load_relaxed(&b->partitions));
         assert(bpart);
         struct implicit_search_resolution resolution = jl_resolve_implicit_import(b, NULL, new_max_world+1, 0);
-        if (resolution.min_world == bpart->min_world) {
-            assert(bpart->restriction == resolution.binding_or_const && jl_binding_kind(bpart) == resolution.ultimate_kind);
+        int resolution_unchanged = bpart->restriction == resolution.binding_or_const && jl_binding_kind(bpart) == resolution.ultimate_kind;
+        size_t bpart_min_world = jl_atomic_load_relaxed(&bpart->min_world);
+        if (resolution.min_world == bpart_min_world) {
+            // The resolution has the same world bounds - it must be unchanged
+            assert(resolution_unchanged);
+            return bpart;
+        } else if (resolution_unchanged) {
+            // If the resolution is unchanged, we can still keep the bpart
+            assert(resolution.min_world > bpart_min_world);
             return bpart;
         }
         assert(resolution.min_world == new_max_world+1 && "Missed an invalidation or bad resolution bounds");
@@ -299,7 +364,7 @@ JL_DLLEXPORT jl_binding_partition_t *jl_maybe_reresolve_implicit(jl_binding_t *b
 JL_DLLEXPORT void jl_update_loaded_bpart(jl_binding_t *b, jl_binding_partition_t *bpart)
 {
     struct implicit_search_resolution resolution = jl_resolve_implicit_import(b, NULL, jl_atomic_load_relaxed(&jl_world_counter), 0);
-    bpart->min_world = resolution.min_world;
+    jl_atomic_store_relaxed(&bpart->min_world, resolution.min_world);
     jl_atomic_store_relaxed(&bpart->max_world, resolution.max_world);
     bpart->restriction = resolution.binding_or_const;
     bpart->kind = resolution.ultimate_kind;
@@ -336,7 +401,8 @@ jl_binding_partition_t *jl_get_binding_partition(jl_binding_t *b, size_t world)
 jl_binding_partition_t *jl_get_binding_partition_with_hint(jl_binding_t *b, jl_binding_partition_t *prev, size_t world) JL_GLOBALLY_ROOTED {
     // Helper for getting a binding partition for an older world after we've already looked up the partition for a newer world
     assert(b);
-    assert(prev->min_world > world);
+    // TODO: Is it possible for a concurrent lookup to have expanded this bpart, making this false?
+    assert(jl_atomic_load_relaxed(&prev->min_world) > world);
     return jl_get_binding_partition_(b, (jl_value_t*)prev, &prev->next, world, NULL);
 }
 
@@ -362,10 +428,11 @@ JL_DLLEXPORT int jl_get_binding_leaf_partitions_restriction_kind(jl_binding_t *b
     while (validated_min_world > min_world) {
         bpart = bpart ? jl_get_binding_partition_with_hint(b, bpart, validated_min_world - 1) :
                         jl_get_binding_partition(b, validated_min_world - 1);
-        while (validated_min_world > min_world && validated_min_world > bpart->min_world) {
+        size_t bpart_min_world = jl_atomic_load_relaxed(&bpart->min_world);
+        while (validated_min_world > min_world && validated_min_world > bpart_min_world) {
             jl_binding_t *curb = b;
             jl_binding_partition_t *curbpart = bpart;
-            size_t cur_min_world = bpart->min_world;
+            size_t cur_min_world = bpart_min_world;
             size_t cur_max_world = validated_min_world - 1;
             jl_walk_binding_inplace_worlds(&curb, &curbpart, &cur_min_world, &cur_max_world, &maybe_depwarn, cur_max_world);
             enum jl_partition_kind kind = jl_binding_kind(curbpart);
@@ -494,7 +561,7 @@ JL_DLLEXPORT jl_binding_partition_t *jl_declare_constant_val3(
             jl_errorf("cannot declare %s.%s constant; it was already declared global",
                       jl_symbol_name(mod->name), jl_symbol_name(var));
         }
-        if (bpart->min_world == new_world) {
+        if (jl_atomic_load_relaxed(&bpart->min_world) == new_world) {
             bpart->kind = constant_kind | (bpart->kind & PARTITION_MASK_FLAG);
             bpart->restriction = val;
             if (val)
@@ -515,9 +582,10 @@ JL_DLLEXPORT jl_binding_partition_t *jl_declare_constant_val3(
                     need_backdate = 0;
                     break;
                 }
-                if (prev_bpart->min_world == 0)
+                size_t prev_bpart_min_world = jl_atomic_load_relaxed(&prev_bpart->min_world);
+                if (prev_bpart_min_world == 0)
                     break;
-                prev_bpart = jl_get_binding_partition(b, prev_bpart->min_world - 1);
+                prev_bpart = jl_get_binding_partition(b, prev_bpart_min_world - 1);
             }
         }
         // If backdate is required, replace each existing partition by a new one.
@@ -530,7 +598,8 @@ JL_DLLEXPORT jl_binding_partition_t *jl_declare_constant_val3(
             while (1) {
                 backdate_bpart->kind = (size_t)PARTITION_KIND_BACKDATED_CONST | (prev_bpart->kind & 0xf0);
                 backdate_bpart->restriction = val;
-                backdate_bpart->min_world = prev_bpart->min_world;
+                jl_atomic_store_relaxed(&backdate_bpart->min_world,
+                    jl_atomic_load_relaxed(&prev_bpart->min_world));
                 jl_gc_wb_fresh(backdate_bpart, val);
                 jl_atomic_store_relaxed(&backdate_bpart->max_world,
                     jl_atomic_load_relaxed(&prev_bpart->max_world));
@@ -861,17 +930,19 @@ JL_DLLEXPORT jl_value_t *jl_get_binding_value_if_const(jl_binding_t *b)
     return bpart->restriction;
 }
 
-JL_DLLEXPORT jl_value_t *jl_get_binding_value_if_resolved_and_const(jl_binding_t *b)
+JL_DLLEXPORT jl_value_t *jl_get_binding_value_if_latest_resolved_and_const_debug_only(jl_binding_t *b)
 {
     // Unlike jl_get_binding_value_if_const this doesn't try to allocate new binding partitions if they
-    // don't already exist, making this JL_NOTSAFEPOINT.
+    // don't already exist, making this JL_NOTSAFEPOINT. However, as a result, this may fail to return
+    // a value - even if one does exist. It should only be used for reflection/debugging when the integrity
+    // of the runtime is not guaranteed.
     if (!b)
         return NULL;
     jl_binding_partition_t *bpart = jl_atomic_load_relaxed(&b->partitions);
     if (!bpart)
         return NULL;
     size_t max_world = jl_atomic_load_relaxed(&bpart->max_world);
-    if (bpart->min_world > jl_current_task->world_age || jl_current_task->world_age > max_world)
+    if (jl_atomic_load_relaxed(&bpart->min_world) > jl_current_task->world_age || jl_current_task->world_age > max_world)
         return NULL;
     enum jl_partition_kind kind = jl_binding_kind(bpart);
     if (jl_bkind_is_some_guard(kind))
@@ -882,17 +953,16 @@ JL_DLLEXPORT jl_value_t *jl_get_binding_value_if_resolved_and_const(jl_binding_t
     return bpart->restriction;
 }
 
-JL_DLLEXPORT jl_value_t *jl_get_binding_value_if_resolved(jl_binding_t *b)
+JL_DLLEXPORT jl_value_t *jl_get_binding_value_if_resolved_debug_only(jl_binding_t *b)
 {
-    // Unlike jl_get_binding_value this doesn't try to allocate new binding partitions if they
-    // don't already exist, making this JL_NOTSAFEPOINT.
+    // See note above. Use for debug/reflection purposes only.
     if (!b)
         return NULL;
     jl_binding_partition_t *bpart = jl_atomic_load_relaxed(&b->partitions);
     if (!bpart)
         return NULL;
     size_t max_world = jl_atomic_load_relaxed(&bpart->max_world);
-    if (bpart->min_world > jl_current_task->world_age || jl_current_task->world_age > max_world)
+    if (jl_atomic_load_relaxed(&bpart->min_world) > jl_current_task->world_age || jl_current_task->world_age > max_world)
         return NULL;
     enum jl_partition_kind kind = jl_binding_kind(bpart);
     if (jl_bkind_is_some_guard(kind))
@@ -1486,7 +1556,7 @@ JL_DLLEXPORT void jl_set_initial_const(jl_module_t *m JL_ROOTING_ARGUMENT, jl_sy
     // jl_declare_constant_val3(NULL, m, var, (jl_value_t*)jl_any_type, kind, 0);
     jl_binding_t *bp = jl_get_module_binding(m, var, 1);
     jl_binding_partition_t *bpart = jl_get_binding_partition(bp, 0);
-    assert(bpart->min_world == 0);
+    assert(jl_atomic_load_relaxed(&bpart->min_world) == 0);
     jl_atomic_store_relaxed(&bpart->max_world, ~(size_t)0); // jl_check_new_binding_implicit likely incorrectly truncated it
     if (exported)
         jl_atomic_fetch_or_relaxed(&bp->flags, BINDING_FLAG_PUBLICP);
@@ -1500,7 +1570,7 @@ JL_DLLEXPORT void jl_set_const(jl_module_t *m JL_ROOTING_ARGUMENT, jl_sym_t *var
     // this function is dangerous and unsound. do not use.
     jl_binding_t *bp = jl_get_module_binding(m, var, 1);
     jl_binding_partition_t *bpart = jl_get_binding_partition(bp, jl_current_task->world_age);
-    bpart->min_world = 0;
+    jl_atomic_store_relaxed(&bpart->min_world, 0);
     jl_atomic_store_release(&bpart->max_world, ~(size_t)0);
     bpart->kind = PARTITION_KIND_CONST | (bpart->kind & PARTITION_MASK_FLAG);
     bpart->restriction = val;
@@ -1583,7 +1653,7 @@ JL_DLLEXPORT jl_binding_partition_t *jl_replace_binding_locked2(jl_binding_t *b,
     assert(jl_atomic_load_relaxed(&b->partitions) == old_bpart);
     jl_binding_partition_t *new_bpart = new_binding_partition();
     JL_GC_PUSH1(&new_bpart);
-    new_bpart->min_world = new_world;
+    jl_atomic_store_relaxed(&new_bpart->min_world, new_world);
     if ((kind & PARTITION_MASK_KIND) == PARTITION_FAKE_KIND_IMPLICIT_RECOMPUTE) {
         assert(!restriction_val);
         struct implicit_search_resolution resolution = jl_resolve_implicit_import(b, NULL, new_world, 0);
@@ -1635,7 +1705,7 @@ JL_DLLEXPORT jl_binding_partition_t *jl_replace_binding(jl_binding_t *b,
 
     size_t new_world = jl_atomic_load_acquire(&jl_world_counter)+1;
     jl_binding_partition_t *bpart = jl_replace_binding_locked(b, old_bpart, restriction_val, kind, new_world);
-    if (bpart && bpart->min_world == new_world)
+    if (bpart && jl_atomic_load_relaxed(&bpart->min_world) == new_world)
         jl_atomic_store_release(&jl_world_counter, new_world);
 
     JL_UNLOCK(&world_counter_lock);
diff --git a/src/rtutils.c b/src/rtutils.c
index 6515b80c5d2b5..3283388cb1d9b 100644
--- a/src/rtutils.c
+++ b/src/rtutils.c
@@ -579,7 +579,7 @@ JL_DLLEXPORT jl_value_t *jl_stderr_obj(void) JL_NOTSAFEPOINT
     if (jl_base_module == NULL)
         return NULL;
     jl_binding_t *stderr_obj = jl_get_module_binding(jl_base_module, jl_symbol("stderr"), 0);
-    return stderr_obj ? jl_get_binding_value_if_resolved(stderr_obj) : NULL;
+    return stderr_obj ? jl_get_binding_value_if_resolved_debug_only(stderr_obj) : NULL;
 }
 
 // toys for debugging ---------------------------------------------------------
@@ -674,7 +674,7 @@ static int is_globname_binding(jl_value_t *v, jl_datatype_t *dv) JL_NOTSAFEPOINT
     jl_sym_t *globname = dv->name->mt != NULL ? dv->name->mt->name : NULL;
     if (globname && dv->name->module) {
         jl_binding_t *b = jl_get_module_binding(dv->name->module, globname, 0);
-        jl_value_t *bv = jl_get_binding_value_if_resolved_and_const(b);
+        jl_value_t *bv = jl_get_binding_value_if_latest_resolved_and_const_debug_only(b);
         // The `||` makes this function work for both function instances and function types.
         if (bv && (bv == v || jl_typeof(bv) == v))
             return 1;
diff --git a/src/staticdata.c b/src/staticdata.c
index b51013e7e0563..62fad8c5a26bd 100644
--- a/src/staticdata.c
+++ b/src/staticdata.c
@@ -1776,7 +1776,7 @@ static void jl_write_values(jl_serializer_state *s) JL_GC_DISABLED
                     write_uint(f, 0);
                 }
             } else {
-                write_uint(f, bpart->min_world);
+                write_uint(f, jl_atomic_load_relaxed(&bpart->min_world));
                 write_uint(f, max_world);
             }
             write_pointerfield(s, (jl_value_t*)jl_atomic_load_relaxed(&bpart->next));
@@ -3597,7 +3597,7 @@ static int jl_validate_binding_partition(jl_binding_t *b, jl_binding_partition_t
         // and allocate a fresh bpart?
         jl_update_loaded_bpart(b, bpart);
         bpart->kind |= (raw_kind & PARTITION_MASK_FLAG);
-        if (bpart->min_world > jl_require_world)
+        if (jl_atomic_load_relaxed(&bpart->min_world) > jl_require_world)
             goto invalidated;
     }
     if (!jl_bkind_is_some_explicit_import(kind) && kind != PARTITION_KIND_IMPLICIT_GLOBAL)
@@ -3608,7 +3608,8 @@ static int jl_validate_binding_partition(jl_binding_t *b, jl_binding_partition_t
     jl_binding_partition_t *latest_imported_bpart = jl_atomic_load_relaxed(&imported_binding->partitions);
     if (!latest_imported_bpart)
         return 1;
-    if (latest_imported_bpart->min_world <= bpart->min_world) {
+    if (jl_atomic_load_relaxed(&latest_imported_bpart->min_world) <=
+        jl_atomic_load_relaxed(&bpart->min_world)) {
 add_backedge:
         // Imported binding is still valid
         if ((kind == PARTITION_KIND_EXPLICIT || kind == PARTITION_KIND_IMPORTED) &&
@@ -3619,8 +3620,9 @@ static int jl_validate_binding_partition(jl_binding_t *b, jl_binding_partition_t
     }
     else {
         // Binding partition was invalidated
-        assert(bpart->min_world == jl_require_world);
-        bpart->min_world = latest_imported_bpart->min_world;
+        assert(jl_atomic_load_relaxed(&bpart->min_world) == jl_require_world);
+        jl_atomic_store_relaxed(&bpart->min_world,
+            jl_atomic_load_relaxed(&latest_imported_bpart->min_world));
     }
 invalidated:
     // We need to go through and re-validate any bindings in the same image that
diff --git a/src/toplevel.c b/src/toplevel.c
index cbf220f0016f1..f1fff694926ba 100644
--- a/src/toplevel.c
+++ b/src/toplevel.c
@@ -309,7 +309,7 @@ void jl_declare_global(jl_module_t *m, jl_value_t *arg, jl_value_t *set_type, in
                     goto check_type;
                 }
                 check_safe_newbinding(gm, gs);
-                if (bpart->min_world == new_world) {
+                if (jl_atomic_load_relaxed(&bpart->min_world) == new_world) {
                     bpart->kind = new_kind | (bpart->kind & PARTITION_MASK_FLAG);
                     bpart->restriction = global_type;
                     if (global_type)
@@ -730,7 +730,7 @@ JL_DLLEXPORT jl_binding_partition_t *jl_declare_constant_val2(
     JL_LOCK(&world_counter_lock);
     size_t new_world = jl_atomic_load_relaxed(&jl_world_counter) + 1;
     jl_binding_partition_t *bpart = jl_declare_constant_val3(b, mod, var, val, constant_kind, new_world);
-    if (bpart->min_world == new_world)
+    if (jl_atomic_load_relaxed(&bpart->min_world) == new_world)
         jl_atomic_store_release(&jl_world_counter, new_world);
     JL_UNLOCK(&world_counter_lock);
     return bpart;
diff --git a/test/rebinding.jl b/test/rebinding.jl
index ab9696c7f0222..1c2a4d7a0b91c 100644
--- a/test/rebinding.jl
+++ b/test/rebinding.jl
@@ -318,3 +318,68 @@ module UndefinedTransitions
         @test Base.Compiler.is_nothrow(Base.Compiler.decode_effects(ci.ipo_purity_bits))
     end
 end
+
+# Identical implicit partitions should be merge (#57923)
+for binding in (convert(Core.Binding, GlobalRef(Base, :Math)),
+                convert(Core.Binding, GlobalRef(Base, :Intrinsics)))
+    # Test that these both only have two partitions
+    @test isdefined(binding, :partitions)
+    @test isdefined(binding.partitions, :next)
+    @test !isdefined(binding.partitions.next, :next)
+end
+
+# Test various scenarios for implicit partition merging
+module MergeStress
+    for i = 1:5
+        @eval module $(Symbol("M$i"))
+            export x, y
+            const x = 1
+            const y = 2
+        end
+    end
+    const before = Base.get_world_counter()
+    using .M1
+    const afterM1 = Base.get_world_counter()
+    using .M2
+    const afterM2 = Base.get_world_counter()
+    using .M3
+    const afterM3 = Base.get_world_counter()
+    using .M4
+    const afterM4 = Base.get_world_counter()
+    using .M5
+    const afterM5 = Base.get_world_counter()
+end
+
+function count_partitions(b::Core.Binding)
+    n = 0
+    isdefined(b, :partitions) || return n
+    bpart = b.partitions
+    while true
+        n += 1
+        isdefined(bpart, :next) || break
+        bpart = bpart.next
+    end
+    return n
+end
+using Base: invoke_in_world
+
+const xbinding = convert(Core.Binding, GlobalRef(MergeStress, :x))
+function access_and_count(point)
+    invoke_in_world(getglobal(MergeStress, point), getglobal, MergeStress, :x)
+    count_partitions(xbinding)
+end
+
+@test count_partitions(xbinding) == 0
+@test access_and_count(:afterM1) == 1
+# M2 is the first change to the `usings` table after M1. The partitions
+# can and should be merged
+@test access_and_count(:afterM2) == 1
+
+# There is a gap between M2 and M5 - the partitions should not be merged
+@test access_and_count(:afterM5) == 2
+
+# M4 and M5 are adjacent, these partitions should also be merged (in the opposite direction)
+@test access_and_count(:afterM4) == 2
+
+# M3 connects all, so we should have a single partition
+@test access_and_count(:afterM3) == 1

From bba8a822e94a45c048e25c9d8dded11a34968de9 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Fri, 18 Apr 2025 22:58:02 +0900
Subject: [PATCH 27/38] inference: minor refactoring on
 abstractinterpretation.jl (#58154)

- add missing `@nospecialize` annotation
- add more type annotations to functions
- fixed capturing uninferrable variables
---
 Compiler/src/abstractinterpretation.jl | 39 +++++++++++++++++---------
 1 file changed, 25 insertions(+), 14 deletions(-)

diff --git a/Compiler/src/abstractinterpretation.jl b/Compiler/src/abstractinterpretation.jl
index 94d5b11a18ca5..f9956f9dfdcf2 100644
--- a/Compiler/src/abstractinterpretation.jl
+++ b/Compiler/src/abstractinterpretation.jl
@@ -2433,6 +2433,7 @@ function abstract_eval_getglobal(interp::AbstractInterpreter, sv::AbsIntState, s
 end
 
 @nospecs function abstract_eval_get_binding_type(interp::AbstractInterpreter, sv::AbsIntState, M, s)
+    @nospecialize M s
     ⊑ = partialorder(typeinf_lattice(interp))
     if isa(M, Const) && isa(s, Const)
         (M, s) = (M.val, s.val)
@@ -2440,7 +2441,7 @@ end
             return CallMeta(Union{}, TypeError, EFFECTS_THROWS, NoCallInfo())
         end
         gr = GlobalRef(M, s)
-        (valid_worlds, rt) = scan_leaf_partitions(interp, gr, sv.world) do interp, _, partition
+        (valid_worlds, rt) = scan_leaf_partitions(interp, gr, sv.world) do interp::AbstractInterpreter, ::Core.Binding, partition::Core.BindingPartition
             local rt
             kind = binding_kind(partition)
             if is_some_guard(kind) || kind == PARTITION_KIND_DECLARED
@@ -2570,13 +2571,14 @@ function abstract_eval_replaceglobal!(interp::AbstractInterpreter, sv::AbsIntSta
             M isa Module || return CallMeta(Union{}, TypeError, EFFECTS_THROWS, NoCallInfo())
             s isa Symbol || return CallMeta(Union{}, TypeError, EFFECTS_THROWS, NoCallInfo())
             gr = GlobalRef(M, s)
-            (valid_worlds, (rte, T)) = scan_leaf_partitions(interp, gr, sv.world) do interp, binding, partition
+            v′ = RefValue{Any}(v)
+            (valid_worlds, (rte, T)) = scan_leaf_partitions(interp, gr, sv.world) do interp::AbstractInterpreter, binding::Core.Binding, partition::Core.BindingPartition
                 partition_T = nothing
                 partition_rte = abstract_eval_partition_load(interp, binding, partition)
                 if binding_kind(partition) == PARTITION_KIND_GLOBAL
                     partition_T = partition_restriction(partition)
                 end
-                partition_exct = Union{partition_rte.exct, global_assignment_binding_rt_exct(interp, partition, v)[2]}
+                partition_exct = Union{partition_rte.exct, global_assignment_binding_rt_exct(interp, partition, v′[])[2]}
                 partition_rte = RTEffects(partition_rte.rt, partition_exct, partition_rte.effects)
                 Pair{RTEffects, Any}(partition_rte, partition_T)
             end
@@ -3511,7 +3513,7 @@ function abstract_eval_binding_partition!(interp::AbstractInterpreter, g::Global
     return partition
 end
 
-function abstract_eval_partition_load(interp::Union{AbstractInterpreter, Nothing}, binding::Core.Binding, partition::Core.BindingPartition)
+function abstract_eval_partition_load(interp::Union{AbstractInterpreter,Nothing}, binding::Core.Binding, partition::Core.BindingPartition)
     kind = binding_kind(partition)
     isdepwarn = (partition.kind & PARTITION_FLAG_DEPWARN) != 0
     local_getglobal_effects = Effects(generic_getglobal_effects, effect_free=isdepwarn ? ALWAYS_FALSE : ALWAYS_TRUE)
@@ -3560,7 +3562,7 @@ function abstract_eval_partition_load(interp::Union{AbstractInterpreter, Nothing
     return RTEffects(rt, exct, effects)
 end
 
-function scan_specified_partitions(query::Function, walk_binding_partition::Function, interp, g::GlobalRef, wwr::WorldWithRange)
+function scan_specified_partitions(query::Function, walk_binding_partition::Function, interp::Union{AbstractInterpreter,Nothing}, g::GlobalRef, wwr::WorldWithRange)
     local total_validity, rte, binding_partition
     binding = convert(Core.Binding, g)
     lookup_world = max_world(wwr.valid_worlds)
@@ -3593,19 +3595,25 @@ function scan_specified_partitions(query::Function, walk_binding_partition::Func
     return Pair{WorldRange, typeof(rte)}(total_validity, rte)
 end
 
-scan_leaf_partitions(query::Function, interp, g::GlobalRef, wwr::WorldWithRange) =
+scan_leaf_partitions(query::Function, ::Nothing, g::GlobalRef, wwr::WorldWithRange) =
+    scan_specified_partitions(query, walk_binding_partition, nothing, g, wwr)
+scan_leaf_partitions(query::Function, interp::AbstractInterpreter, g::GlobalRef, wwr::WorldWithRange) =
     scan_specified_partitions(query, walk_binding_partition, interp, g, wwr)
 
-scan_partitions(query::Function, interp, g::GlobalRef, wwr::WorldWithRange) =
-    scan_specified_partitions(query,
-        (b::Core.Binding, bpart::Core.BindingPartition, world::UInt)->
-            Pair{WorldRange, Pair{Core.Binding, Core.BindingPartition}}(WorldRange(bpart.min_world, bpart.max_world), b=>bpart),
-        interp, g, wwr)
+function scan_partitions(query::Function, interp::AbstractInterpreter, g::GlobalRef, wwr::WorldWithRange)
+    walk_binding_partition = function (b::Core.Binding, partition::Core.BindingPartition, world::UInt)
+        Pair{WorldRange, Pair{Core.Binding, Core.BindingPartition}}(
+            WorldRange(partition.min_world, partition.max_world), b=>partition)
+    end
+    return scan_specified_partitions(query, walk_binding_partition, interp, g, wwr)
+end
 
-abstract_load_all_consistent_leaf_partitions(interp, g::GlobalRef, wwr::WorldWithRange) =
+abstract_load_all_consistent_leaf_partitions(interp::AbstractInterpreter, g::GlobalRef, wwr::WorldWithRange) =
     scan_leaf_partitions(abstract_eval_partition_load, interp, g, wwr)
+abstract_load_all_consistent_leaf_partitions(::Nothing, g::GlobalRef, wwr::WorldWithRange) =
+    scan_leaf_partitions(abstract_eval_partition_load, nothing, g, wwr)
 
-function abstract_eval_globalref(interp, g::GlobalRef, saw_latestworld::Bool, sv::AbsIntState)
+function abstract_eval_globalref(interp::AbstractInterpreter, g::GlobalRef, saw_latestworld::Bool, sv::AbsIntState)
     if saw_latestworld
         return RTEffects(Any, Any, generic_getglobal_effects)
     end
@@ -3621,7 +3629,10 @@ function global_assignment_rt_exct(interp::AbstractInterpreter, sv::AbsIntState,
     if saw_latestworld
         return Pair{Any,Any}(newty, ErrorException)
     end
-    (valid_worlds, ret) = scan_partitions((interp, _, partition)->global_assignment_binding_rt_exct(interp, partition, newty), interp, g, sv.world)
+    newty′ = RefValue{Any}(newty)
+    (valid_worlds, ret) = scan_partitions(interp, g, sv.world) do interp::AbstractInterpreter, ::Core.Binding, partition::Core.BindingPartition
+        global_assignment_binding_rt_exct(interp, partition, newty′[])
+    end
     update_valid_age!(sv, valid_worlds)
     return ret
 end

From 151591318322df0b4ddbff20c738e619cff587cf Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Wed, 16 Apr 2025 13:26:08 -0400
Subject: [PATCH 28/38] fix static show in some edge cases (#58128)

Fix #51870

In a different PR, I was making precompile printing slightly more
accurate, and it caused nearly everything to run into this bug and
crashed the build, so I needed to fix this now since an upcoming PR will
rely heavily on this being corrected.

(cherry picked from commit 1faa69853e3a9e9456b27a5f6a954b26400569ca)
---
 src/rtutils.c | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/rtutils.c b/src/rtutils.c
index 3283388cb1d9b..5966497ec331c 100644
--- a/src/rtutils.c
+++ b/src/rtutils.c
@@ -675,8 +675,7 @@ static int is_globname_binding(jl_value_t *v, jl_datatype_t *dv) JL_NOTSAFEPOINT
     if (globname && dv->name->module) {
         jl_binding_t *b = jl_get_module_binding(dv->name->module, globname, 0);
         jl_value_t *bv = jl_get_binding_value_if_latest_resolved_and_const_debug_only(b);
-        // The `||` makes this function work for both function instances and function types.
-        if (bv && (bv == v || jl_typeof(bv) == v))
+        if (bv && ((jl_value_t*)dv == v ? jl_typeof(bv) == v : bv == v))
             return 1;
     }
     return 0;

From bcb103afa3c6679fba25be8cfd9f02ab9c206a4e Mon Sep 17 00:00:00 2001
From: Cody Tapscott <84105208+topolarity@users.noreply.github.com>
Date: Sat, 19 Apr 2025 02:18:31 -0400
Subject: [PATCH 29/38] Fix `jl_set_precompile_field_replace` for 0-size fields
 (#58155)

(cherry picked from commit 73410981c85cf6e8005922439bef554cd06b3b0d)
---
 src/staticdata.c   | 4 ++--
 test/precompile.jl | 5 +++++
 2 files changed, 7 insertions(+), 2 deletions(-)

diff --git a/src/staticdata.c b/src/staticdata.c
index 62fad8c5a26bd..d8420c2d81f3b 100644
--- a/src/staticdata.c
+++ b/src/staticdata.c
@@ -1794,7 +1794,7 @@ static void jl_write_values(jl_serializer_state *s) JL_GC_DISABLED
                 tot = offset;
                 size_t fsz = jl_field_size(t, i);
                 jl_value_t *replace = (jl_value_t*)ptrhash_get(&bits_replace, (void*)slot);
-                if (replace != HT_NOTFOUND) {
+                if (replace != HT_NOTFOUND && fsz > 0) {
                     assert(t->name->mutabl && !jl_field_isptr(t, i));
                     jl_value_t *rty = jl_typeof(replace);
                     size_t sz = jl_datatype_size(rty);
@@ -3013,7 +3013,7 @@ static void jl_save_system_image_to_stream(ios_t *f, jl_array_t *mod_array,
             if (jl_field_isptr(st, field)) {
                 record_field_change((jl_value_t**)fldaddr, newval);
             }
-            else {
+            else if (jl_field_size(st, field) > 0) {
                 // replace the bits
                 ptrhash_put(&bits_replace, (void*)fldaddr, newval);
                 // and any pointers inside
diff --git a/test/precompile.jl b/test/precompile.jl
index f7b31c125014c..50686d0b47cb9 100644
--- a/test/precompile.jl
+++ b/test/precompile.jl
@@ -105,6 +105,11 @@ precompile_test_harness(false) do dir
               process_state_calls = 0
               @assert process_state() === process_state()
               @assert process_state_calls === 0
+
+              const empty_state = Base.OncePerProcess{Nothing}() do
+                  return nothing
+              end
+              @assert empty_state() === nothing
           end
           """)
     write(Foo2_file,

From 66a3cc96d80494ecb01ce0c1ea549279ddbc3417 Mon Sep 17 00:00:00 2001
From: adienes <51664769+adienes@users.noreply.github.com>
Date: Sat, 19 Apr 2025 09:05:09 -0400
Subject: [PATCH 30/38] Switch from segfault to `zip` behavior for mismatched
 indices in `map!` (#56673)

(cherry picked from commit 0947114d9d443e14c751ac40c9b2d8c2245d045e)
---
 base/abstractarray.jl | 19 +++++++++++++------
 test/abstractarray.jl | 20 ++++++++++++++++++++
 2 files changed, 33 insertions(+), 6 deletions(-)

diff --git a/base/abstractarray.jl b/base/abstractarray.jl
index 62bf0901a0507..2632592ede7c1 100644
--- a/base/abstractarray.jl
+++ b/base/abstractarray.jl
@@ -3412,12 +3412,19 @@ function ith_all(i, as)
 end
 
 function map_n!(f::F, dest::AbstractArray, As) where F
-    idxs1 = LinearIndices(As[1])
-    @boundscheck LinearIndices(dest) == idxs1 && all(x -> LinearIndices(x) == idxs1, As)
-    for i = idxs1
-        @inbounds I = ith_all(i, As)
-        val = f(I...)
-        @inbounds dest[i] = val
+    idxs = LinearIndices(dest)
+    if all(x -> LinearIndices(x) == idxs, As)
+        for i in idxs
+            @inbounds as = ith_all(i, As)
+            val = f(as...)
+            @inbounds dest[i] = val
+        end
+    else
+        for (i, Is...) in zip(eachindex(dest), map(eachindex, As)...)
+            as = ntuple(j->getindex(As[j], Is[j]), length(As))
+            val = f(as...)
+            dest[i] = val
+        end
     end
     return dest
 end
diff --git a/test/abstractarray.jl b/test/abstractarray.jl
index d1f30eacafacc..6d4712c93a9c4 100644
--- a/test/abstractarray.jl
+++ b/test/abstractarray.jl
@@ -910,6 +910,26 @@ include("generic_map_tests.jl")
 generic_map_tests(map, map!)
 @test map!(-, [1]) == [-1]
 
+@testset "#30624" begin
+    ### unstructured
+    @test map!(+, ones(3), ones(3), ones(3), [1]) == [3, 1, 1]
+    @test map!(+, ones(3), [1], ones(3), ones(3)) == [3, 1, 1]
+    @test map!(+, [1], [1], [], []) == [1]
+    @test map!(+, [[1]], [1], [], []) == [[1]]
+
+    # TODO: decide if input axes & lengths should be validated
+    # @test_throws BoundsError map!(+, ones(1), ones(2))
+    # @test_throws BoundsError map!(+, ones(1), ones(2, 2))
+
+    @test map!(+, ones(3), view(ones(2, 3), 1:2, 2:3), ones(3)) == [2, 2, 2]
+    @test map!(+, ones(3), ones(2, 2), ones(3)) == [2, 2, 2]
+
+    ### structured (all mapped arguments are <:AbstractArray equal ndims > 1)
+    @test map!(+, ones(4), ones(2, 2), ones(2, 2)) == [2, 2, 2, 2]
+    @test map!(+, ones(4), ones(2, 2), ones(1, 2)) == [2, 2, 1, 1]
+    # @test_throws BoundsError map!(+, ones(3), ones(2, 2), ones(2, 2))
+end
+
 test_UInt_indexing(TestAbstractArray)
 test_13315(TestAbstractArray)
 test_checksquare()

From f1517b46f90fd54fa0d973a4601a792420079e13 Mon Sep 17 00:00:00 2001
From: N5N3 <2642243996@qq.com>
Date: Sun, 20 Apr 2025 18:48:32 +0800
Subject: [PATCH 31/38] =?UTF-8?q?subtype:=20save=20some=20union=20stack=20?=
 =?UTF-8?q?space=20for=20=E2=88=83=20free=20cases.=20(#58159)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

and avoid eager UnionAll unwrapping to hit more fast path.
close #58129 (test passed locally)
close #56350 (MWE returns `Tuple{Any, Any, Vararg}` now.)

(cherry picked from commit 334c3167e853daeb11e5121d2041de657e175726)
---
 src/subtype.c   | 34 +++++++++++++++++++++++++---------
 test/subtype.jl | 14 ++++++++++++++
 2 files changed, 39 insertions(+), 9 deletions(-)

diff --git a/src/subtype.c b/src/subtype.c
index c1c811d4e0ad5..ed6a8818dc3f2 100644
--- a/src/subtype.c
+++ b/src/subtype.c
@@ -139,7 +139,7 @@ static jl_varbinding_t *lookup(jl_stenv_t *e, jl_tvar_t *v) JL_GLOBALLY_ROOTED J
 
 static int statestack_get(jl_unionstate_t *st, int i) JL_NOTSAFEPOINT
 {
-    assert(i >= 0 && i <= 32767); // limited by the depth bit.
+    assert(i >= 0 && i < 32767); // limited by the depth bit.
     // get the `i`th bit in an array of 32-bit words
     jl_bits_stack_t *stack = &st->stack;
     while (i >= sizeof(stack->data) * 8) {
@@ -153,7 +153,7 @@ static int statestack_get(jl_unionstate_t *st, int i) JL_NOTSAFEPOINT
 
 static void statestack_set(jl_unionstate_t *st, int i, int val) JL_NOTSAFEPOINT
 {
-    assert(i >= 0 && i <= 32767); // limited by the depth bit.
+    assert(i >= 0 && i < 32767); // limited by the depth bit.
     jl_bits_stack_t *stack = &st->stack;
     while (i >= sizeof(stack->data) * 8) {
         if (__unlikely(stack->next == NULL)) {
@@ -1448,11 +1448,14 @@ static int subtype(jl_value_t *x, jl_value_t *y, jl_stenv_t *e, int param)
         }
         if (jl_is_unionall(y)) {
             jl_varbinding_t *xb = lookup(e, (jl_tvar_t*)x);
-            if (xb == NULL ? !e->ignore_free : !xb->right) {
+            jl_value_t *xub = xb == NULL ? ((jl_tvar_t *)x)->ub : xb->ub;
+            if ((xb == NULL ? !e->ignore_free : !xb->right) && xub != y) {
                 // We'd better unwrap `y::UnionAll` eagerly if `x` isa ∀-var.
                 // This makes sure the following cases work correct:
                 // 1) `∀T <: Union{∃S, SomeType{P}} where {P}`: `S == Any` ==> `S >: T`
                 // 2) `∀T <: Union{∀T, SomeType{P}} where {P}`:
+                // note: if xub == y we'd better try `subtype_var` as `subtype_left_var`
+                // hit `==` based fast path.
                 return subtype_unionall(x, (jl_unionall_t*)y, e, 1, param);
             }
         }
@@ -1590,6 +1593,8 @@ static int has_exists_typevar(jl_value_t *x, jl_stenv_t *e) JL_NOTSAFEPOINT
     return env != NULL && jl_has_bound_typevars(x, env);
 }
 
+static int forall_exists_subtype(jl_value_t *x, jl_value_t *y, jl_stenv_t *e, int param);
+
 static int local_forall_exists_subtype(jl_value_t *x, jl_value_t *y, jl_stenv_t *e, int param, int limit_slow)
 {
     int16_t oldRmore = e->Runions.more;
@@ -1603,7 +1608,18 @@ static int local_forall_exists_subtype(jl_value_t *x, jl_value_t *y, jl_stenv_t
         return jl_subtype(x, y);
     int has_exists = (!kindx && has_exists_typevar(x, e)) ||
                      (!kindy && has_exists_typevar(y, e));
-    if (has_exists && (is_exists_typevar(x, e) != is_exists_typevar(y, e))) {
+    if (!has_exists) {
+        // We can use ∀_∃_subtype safely for ∃ free inputs.
+        // This helps to save some bits in union stack.
+        jl_saved_unionstate_t oldRunions; push_unionstate(&oldRunions, &e->Runions);
+        e->Lunions.used = e->Runions.used = 0;
+        e->Lunions.depth = e->Runions.depth = 0;
+        e->Lunions.more = e->Runions.more = 0;
+        sub = forall_exists_subtype(x, y, e, param);
+        pop_unionstate(&e->Runions, &oldRunions);
+        return sub;
+    }
+    if (is_exists_typevar(x, e) != is_exists_typevar(y, e)) {
         e->Lunions.used = 0;
         while (1) {
             e->Lunions.more = 0;
@@ -1617,7 +1633,7 @@ static int local_forall_exists_subtype(jl_value_t *x, jl_value_t *y, jl_stenv_t
     if (limit_slow == -1)
         limit_slow = kindx || kindy;
     jl_savedenv_t se;
-    save_env(e, &se, has_exists);
+    save_env(e, &se, 1);
     int count, limited = 0, ini_count = 0;
     jl_saved_unionstate_t latestLunions = {0, 0, 0, NULL};
     while (1) {
@@ -1635,13 +1651,13 @@ static int local_forall_exists_subtype(jl_value_t *x, jl_value_t *y, jl_stenv_t
                 limited = 1;
             if (!sub || !next_union_state(e, 0))
                 break;
-            if (limited || !has_exists || e->Runions.more == oldRmore) {
+            if (limited || e->Runions.more == oldRmore) {
                 // re-save env and freeze the ∃decision for previous ∀Union
                 // Note: We could ignore the rest `∃Union` decisions if `x` and `y`
                 // contain no ∃ typevar, as they have no effect on env.
                 ini_count = count;
                 push_unionstate(&latestLunions, &e->Lunions);
-                re_save_env(e, &se, has_exists);
+                re_save_env(e, &se, 1);
                 e->Runions.more = oldRmore;
             }
         }
@@ -1649,12 +1665,12 @@ static int local_forall_exists_subtype(jl_value_t *x, jl_value_t *y, jl_stenv_t
             break;
         assert(e->Runions.more > oldRmore);
         next_union_state(e, 1);
-        restore_env(e, &se, has_exists); // also restore Rdepth here
+        restore_env(e, &se, 1); // also restore Rdepth here
         e->Runions.more = oldRmore;
     }
     if (!sub)
         assert(e->Runions.more == oldRmore);
-    else if (limited || !has_exists)
+    else if (limited)
         e->Runions.more = oldRmore;
     free_env(&se);
     return sub;
diff --git a/test/subtype.jl b/test/subtype.jl
index d186262a6e1ba..da69022b1466e 100644
--- a/test/subtype.jl
+++ b/test/subtype.jl
@@ -2768,3 +2768,17 @@ end
     Tuple{Type{Complex{T}} where T, Type{Complex{T}} where T, Type{String}},
     Tuple{Type{Complex{T}}, Type{Complex{T}}, Type{String}} where T
 )
+
+#issue 58129
+for k in 1:500
+    @eval struct $(Symbol(:T58129, k)){T} end
+end
+let Tvar = TypeVar(:Tvar)
+    V = UnionAll(Tvar, Union{(@eval($(Symbol(:T58129, k)){$Tvar}) for k in 1:500)...})
+    @test Set{<:V} <: AbstractSet{<:V}
+end
+let Tvar1 = TypeVar(:Tvar1), Tvar2 = TypeVar(:Tvar2)
+    V1 = UnionAll(Tvar1, Union{(@eval($(Symbol(:T58129, k)){$Tvar1}) for k in 1:100)...})
+    V2 = UnionAll(Tvar2, Union{(@eval($(Symbol(:T58129, k)){$Tvar2}) for k in 1:100)...})
+    @test Set{<:V2} <: AbstractSet{<:V1}
+end

From ea25e2aa19be5a950e3b892f508d5a4108bc5fa1 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Mon, 21 Apr 2025 04:07:46 +0900
Subject: [PATCH 32/38] inference: allow specialization of
 `scan_specified_partitions` (#58165)

Changed the `::Function` signature to the `::F where F` pattern to allow
specialization of `scan_specified_partitions`.

The changes in `scan_leaf_partitions` and `scan_partitions` are not
actually necessary because those methods are simple and are basically
inlined and optimized down to calling `scan_specified_partitions`.
However, considering the possibility of other code being added in the
future and also for consistency, the same changes were applied.

(cherry picked from commit 39d748312492ae2cebc4a4103e42bfd5fa46fe0a)
---
 Compiler/src/abstractinterpretation.jl | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/Compiler/src/abstractinterpretation.jl b/Compiler/src/abstractinterpretation.jl
index f9956f9dfdcf2..fed527dccd283 100644
--- a/Compiler/src/abstractinterpretation.jl
+++ b/Compiler/src/abstractinterpretation.jl
@@ -3562,7 +3562,8 @@ function abstract_eval_partition_load(interp::Union{AbstractInterpreter,Nothing}
     return RTEffects(rt, exct, effects)
 end
 
-function scan_specified_partitions(query::Function, walk_binding_partition::Function, interp::Union{AbstractInterpreter,Nothing}, g::GlobalRef, wwr::WorldWithRange)
+function scan_specified_partitions(query::F1, walk_binding_partition::F2,
+    interp::Union{AbstractInterpreter,Nothing}, g::GlobalRef, wwr::WorldWithRange) where {F1,F2}
     local total_validity, rte, binding_partition
     binding = convert(Core.Binding, g)
     lookup_world = max_world(wwr.valid_worlds)
@@ -3595,12 +3596,12 @@ function scan_specified_partitions(query::Function, walk_binding_partition::Func
     return Pair{WorldRange, typeof(rte)}(total_validity, rte)
 end
 
-scan_leaf_partitions(query::Function, ::Nothing, g::GlobalRef, wwr::WorldWithRange) =
+scan_leaf_partitions(query::F, ::Nothing, g::GlobalRef, wwr::WorldWithRange) where F =
     scan_specified_partitions(query, walk_binding_partition, nothing, g, wwr)
-scan_leaf_partitions(query::Function, interp::AbstractInterpreter, g::GlobalRef, wwr::WorldWithRange) =
+scan_leaf_partitions(query::F, interp::AbstractInterpreter, g::GlobalRef, wwr::WorldWithRange) where F =
     scan_specified_partitions(query, walk_binding_partition, interp, g, wwr)
 
-function scan_partitions(query::Function, interp::AbstractInterpreter, g::GlobalRef, wwr::WorldWithRange)
+function scan_partitions(query::F, interp::AbstractInterpreter, g::GlobalRef, wwr::WorldWithRange) where F
     walk_binding_partition = function (b::Core.Binding, partition::Core.BindingPartition, world::UInt)
         Pair{WorldRange, Pair{Core.Binding, Core.BindingPartition}}(
             WorldRange(partition.min_world, partition.max_world), b=>partition)

From 43c784bf4ff5b9f4c46e30cd8f57d2befffc3977 Mon Sep 17 00:00:00 2001
From: Jameson Nash <vtjnash@gmail.com>
Date: Mon, 21 Apr 2025 15:36:35 -0400
Subject: [PATCH 33/38] gf: make dispatch heuristic representation explicit
 (#58167)

Makes this query more accurate for the rare nonfunction_mt dispatch, but
otherwise not expected to be a visible change. (needed for future
followup work, so splitting this out into a small change since it can be
done independently)

(cherry picked from commit fb31b3c8a3ba6ff6ed5bda0caf83694a3456796c)
---
 src/datatype.c |  1 +
 src/gf.c       | 15 ++++++++++++---
 src/jltypes.c  | 14 ++++++++------
 src/julia.h    |  1 +
 test/core.jl   |  2 +-
 5 files changed, 23 insertions(+), 10 deletions(-)

diff --git a/src/datatype.c b/src/datatype.c
index 4c7e248cf0a52..3f9679ec54618 100644
--- a/src/datatype.c
+++ b/src/datatype.c
@@ -80,6 +80,7 @@ JL_DLLEXPORT jl_typename_t *jl_new_typename_in(jl_sym_t *name, jl_module_t *modu
     tn->partial = NULL;
     tn->atomicfields = NULL;
     tn->constfields = NULL;
+    jl_atomic_store_relaxed(&tn->cache_entry_count, 0);
     tn->max_methods = 0;
     tn->constprop_heustic = 0;
     return tn;
diff --git a/src/gf.c b/src/gf.c
index 209ca0827507f..69bcd916cb7e2 100644
--- a/src/gf.c
+++ b/src/gf.c
@@ -1618,6 +1618,15 @@ jl_method_instance_t *cache_method(
     }
     else {
          jl_typemap_insert(cache, parent, newentry, offs);
+         if (mt) {
+             jl_datatype_t *dt = jl_nth_argument_datatype((jl_value_t*)tt, 1);
+             if (dt) {
+                 jl_typename_t *tn = dt->name;
+                 int cache_entry_count = jl_atomic_load_relaxed(&tn->cache_entry_count);
+                 if (cache_entry_count < 31)
+                     jl_atomic_store_relaxed(&tn->cache_entry_count, cache_entry_count + 1);
+             }
+         }
     }
 
     JL_GC_POP();
@@ -3616,9 +3625,9 @@ STATIC_INLINE jl_method_instance_t *jl_lookup_generic_(jl_value_t *F, jl_value_t
         mt = jl_gf_mtable(F);
         jl_genericmemory_t *leafcache = jl_atomic_load_relaxed(&mt->leafcache);
         entry = NULL;
-        if (leafcache != (jl_genericmemory_t*)jl_an_empty_memory_any &&
-                jl_typetagis(jl_atomic_load_relaxed(&mt->cache), jl_typemap_level_type)) {
-            // hashing args is expensive, but looking at mt->cache is probably even more expensive
+        int cache_entry_count = jl_atomic_load_relaxed(&((jl_datatype_t*)FT)->name->cache_entry_count);
+        if (leafcache != (jl_genericmemory_t*)jl_an_empty_memory_any && (cache_entry_count == 0 || cache_entry_count >= 8)) {
+            // hashing args is expensive, but so do that only if looking at mc->cache is probably even more expensive
             tt = lookup_arg_type_tuple(F, args, nargs);
             if (tt != NULL)
                 entry = lookup_leafcache(leafcache, (jl_value_t*)tt, world);
diff --git a/src/jltypes.c b/src/jltypes.c
index 579da136ef4e9..1fe6aeb0fffb9 100644
--- a/src/jltypes.c
+++ b/src/jltypes.c
@@ -3007,26 +3007,27 @@ void jl_init_types(void) JL_GC_DISABLED
     jl_typename_type->name->mt = jl_nonfunction_mt;
     jl_typename_type->super = jl_any_type;
     jl_typename_type->parameters = jl_emptysvec;
-    jl_typename_type->name->n_uninitialized = 16 - 2;
-    jl_typename_type->name->names = jl_perm_symsvec(16, "name", "module",
+    jl_typename_type->name->n_uninitialized = 17 - 2;
+    jl_typename_type->name->names = jl_perm_symsvec(17, "name", "module",
                                                     "names", "atomicfields", "constfields",
                                                     "wrapper", "Typeofwrapper", "cache", "linearcache",
                                                     "mt", "partial",
                                                     "hash", "n_uninitialized",
                                                     "flags", // "abstract", "mutable", "mayinlinealloc",
-                                                    "max_methods", "constprop_heuristic");
-    const static uint32_t typename_constfields[1] = { 0x00003a27 }; // (1<<0)|(1<<1)|(1<<2)|(1<<5)|(1<<9)|(1<<11)|(1<<12)|(1<<13) ; TODO: put back (1<<3)|(1<<4) in this list
-    const static uint32_t typename_atomicfields[1] = { 0x00000180 }; // (1<<7)|(1<<8)
+                                                    "cache_entry_count", "max_methods", "constprop_heuristic");
+    const static uint32_t typename_constfields[1]  = { 0b00011101000100111 }; // TODO: put back atomicfields and constfields in this list
+    const static uint32_t typename_atomicfields[1] = { 0b00100000110000000 };
     jl_typename_type->name->constfields = typename_constfields;
     jl_typename_type->name->atomicfields = typename_atomicfields;
     jl_precompute_memoized_dt(jl_typename_type, 1);
-    jl_typename_type->types = jl_svec(16, jl_symbol_type, jl_any_type /*jl_module_type*/,
+    jl_typename_type->types = jl_svec(17, jl_symbol_type, jl_any_type /*jl_module_type*/,
                                       jl_simplevector_type, jl_any_type/*jl_voidpointer_type*/, jl_any_type/*jl_voidpointer_type*/,
                                       jl_type_type, jl_type_type, jl_simplevector_type, jl_simplevector_type,
                                       jl_methtable_type, jl_any_type,
                                       jl_any_type /*jl_long_type*/, jl_any_type /*jl_int32_type*/,
                                       jl_any_type /*jl_uint8_type*/,
                                       jl_any_type /*jl_uint8_type*/,
+                                      jl_any_type /*jl_uint8_type*/,
                                       jl_any_type /*jl_uint8_type*/);
 
     jl_methtable_type->name = jl_new_typename_in(jl_symbol("MethodTable"), core, 0, 1);
@@ -3856,6 +3857,7 @@ void jl_init_types(void) JL_GC_DISABLED
     jl_svecset(jl_typename_type->types, 13, jl_uint8_type);
     jl_svecset(jl_typename_type->types, 14, jl_uint8_type);
     jl_svecset(jl_typename_type->types, 15, jl_uint8_type);
+    jl_svecset(jl_typename_type->types, 16, jl_uint8_type);
     jl_svecset(jl_methtable_type->types, 4, jl_long_type);
     jl_svecset(jl_methtable_type->types, 5, jl_module_type);
     jl_svecset(jl_methtable_type->types, 6, jl_array_any_type);
diff --git a/src/julia.h b/src/julia.h
index d8496a9304ccd..6310ee38a2c60 100644
--- a/src/julia.h
+++ b/src/julia.h
@@ -536,6 +536,7 @@ typedef struct {
     uint8_t mutabl:1;
     uint8_t mayinlinealloc:1;
     uint8_t _reserved:5;
+    _Atomic(uint8_t) cache_entry_count; // (approximate counter of TypeMapEntry for heuristics)
     uint8_t max_methods; // override for inference's max_methods setting (0 = no additional limit or relaxation)
     uint8_t constprop_heustic; // override for inference's constprop heuristic
 } jl_typename_t;
diff --git a/test/core.jl b/test/core.jl
index 181fe302eb5a4..8a98cc39b7af8 100644
--- a/test/core.jl
+++ b/test/core.jl
@@ -39,7 +39,7 @@ for (T, c) in (
         (Core.MethodTable, [:defs, :leafcache, :cache, :max_args]),
         (Core.TypeMapEntry, [:next, :min_world, :max_world]),
         (Core.TypeMapLevel, [:arg1, :targ, :name1, :tname, :list, :any]),
-        (Core.TypeName, [:cache, :linearcache]),
+        (Core.TypeName, [:cache, :linearcache, :cache_entry_count]),
         (DataType, [:types, :layout]),
         (Core.Memory, []),
         (Core.GenericMemoryRef, []),

From 408e1da0620571b0cc7e5e24b357d8dcdd2f06b4 Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
Date: Tue, 22 Apr 2025 15:23:03 +0900
Subject: [PATCH 34/38] fix performance regression introduced by #58027
 (#58184)

(cherry picked from commit 473593343c1b2bf00e00775c4bf6b85eebb66c35)
---
 Compiler/src/abstractinterpretation.jl | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/Compiler/src/abstractinterpretation.jl b/Compiler/src/abstractinterpretation.jl
index fed527dccd283..d1e28ce220b13 100644
--- a/Compiler/src/abstractinterpretation.jl
+++ b/Compiler/src/abstractinterpretation.jl
@@ -3681,8 +3681,9 @@ struct AbstractEvalBasicStatementResult
     end
 end
 
-function abstract_eval_basic_statement(interp::AbstractInterpreter, @nospecialize(stmt), sstate::StatementState, frame::InferenceState,
-                                       result::Union{Nothing,Future{RTEffects}}=nothing)
+@inline function abstract_eval_basic_statement(
+    interp::AbstractInterpreter, @nospecialize(stmt), sstate::StatementState, frame::InferenceState,
+    result::Union{Nothing,Future{RTEffects}}=nothing)
     rt = nothing
     exct = Bottom
     changes = nothing

From 8d69739a445709217794e29a20c44024b6cf485f Mon Sep 17 00:00:00 2001
From: Kristoffer Carlsson <kcarlsson89@gmail.com>
Date: Tue, 22 Apr 2025 08:54:53 +0200
Subject: [PATCH 35/38] add showing a string to REPL precompile workload
 (#58157)

(cherry picked from commit 4766133f6c1e7825f3fb35243e353a380eb425d5)
---
 stdlib/REPL/src/precompile.jl | 1 +
 1 file changed, 1 insertion(+)

diff --git a/stdlib/REPL/src/precompile.jl b/stdlib/REPL/src/precompile.jl
index 4f3b3a6eae083..f9f411566a719 100644
--- a/stdlib/REPL/src/precompile.jl
+++ b/stdlib/REPL/src/precompile.jl
@@ -58,6 +58,7 @@ function repl_workload()
     printstyled("a", "b")
     display([1])
     display([1 2; 3 4])
+    display("a string")
     foo(x) = 1
     @time @eval foo(1)
     ; pwd

From d9da4213b9d51140fcb57c6c673652c2f99be859 Mon Sep 17 00:00:00 2001
From: Sam Schweigel <33556084+xal-0@users.noreply.github.com>
Date: Tue, 22 Apr 2025 07:02:15 -0700
Subject: [PATCH 36/38] JuliaSyntax parser-based REPL completions overhaul
 (#57767)

# Overview

As we add REPL features, bugs related to the ad-hoc parsing done by
`REPLCompletions.completions` have crept in. This pull request replaces
most of the manual parsing (regex, `find_start_brace`) with a new
approach that parses the entire input buffer once, before and after the
cursor, using JuliaSyntax. We then query the parsed syntax tree to
determine the kind of completion to be done.

# Changes
- New, JuliaSyntax-based completions mechanism.

- The `complete_line` interface now has the option of replacing
  arbitrary regions of text in the input buffer by returning a `Region`
  (`Pair{Int, Int}` for consistency with the convention in LineEdit, and
  `pos` being a 0-based byte offset).

- Fixes parsing-related bugs:
  - fix #55420
  - fix #55429
  - fix #55518
  - fix #55520
  - fix #55842
  - fix #56389
  - fix #57307
  - fix #57611
  - fix #57624
  - fix #58099

- Fixes some bugs that exist on 28d3bd56d36 that were found by fuzzing:
  - `x \"` + `TAB` throws a `FieldError` exception
  - String completion would sometimes delete the entire input buffer.
  - Completions should not happen inside comments.

- The duplicate code for path completion in strings, `Cmd`-strings, and
  the shell has been removed, causing paths to complete the same way for
  all three. Now, `~` is expanded in two situations:
  - If `foo` exists, or if `foo` does not exist but there are no
    possible completions:
    ```
    "~/foo/b|"     =TAB=>   "~/foo/bar|"
    "~/foo/bar|"   =TAB=>   "/home/user/foo/bar|"
       OR
    "~/foo/bar"|   =TAB=>   "/home/user/foo/bar"|
    ```

  - If the current path ends with a `/` and you hit TAB again:
    ```
    "~/foo/|"      =TAB=>   "/home/user/foo/|"
       OR
    "~/foo/"|      =TAB=>   "/home/user/foo/"|
    ```

# Future work
- Method completions could be changed to look for methods with exactly
  the given number of arguments if the closing `)` is present, and search
  for signatures with the right prefix otherwise.

- It would be nice to be able to search by type as well as value
  (perhaps by putting `::T` in place of arguments).

- Other REPL features could benefit from JuliaSyntax, so it might be
  worth sharing the parse tree between completions and other features:

    - Emacs-style sexpr navigation: `C-M-f`/`C-M-b`/`C-M-u`, etc.
    - Improved auto-indent.

- It would be nice if hints worked even when the cursor is between text.

- `CursorNode` is a slightly tweaked copy of `SyntaxNode` from
  JuliaSyntax that tracks the parent node but includes all trivia. It is
  used with `seek_pos`, which navigates to the innermost node at a given
  position so we can examine nearby nodes and the parent. This could
  probably duplicate less code from JuliaSyntax.

(cherry picked from commit ff0a9313de7542c08279dd7925f5468cf54f6e92)
---
 stdlib/REPL/src/LineEdit.jl         |  60 +-
 stdlib/REPL/src/REPL.jl             |  23 +-
 stdlib/REPL/src/REPLCompletions.jl  | 983 +++++++++++-----------------
 stdlib/REPL/src/SyntaxUtil.jl       | 111 ++++
 stdlib/REPL/test/replcompletions.jl | 270 ++++++--
 5 files changed, 759 insertions(+), 688 deletions(-)
 create mode 100644 stdlib/REPL/src/SyntaxUtil.jl

diff --git a/stdlib/REPL/src/LineEdit.jl b/stdlib/REPL/src/LineEdit.jl
index 288a9cb1ea91f..53e497a6548ee 100644
--- a/stdlib/REPL/src/LineEdit.jl
+++ b/stdlib/REPL/src/LineEdit.jl
@@ -391,16 +391,21 @@ function complete_line(s::MIState)
     end
 end
 
+# Old complete_line return type: Vector{String},          String, Bool
+# New complete_line return type: NamedCompletion{String}, String, Bool
+#                            OR  NamedCompletion{String}, Region, Bool
+#
 # due to close coupling of the Pkg ReplExt `complete_line` can still return a vector of strings,
 # so we convert those in this helper
-function complete_line_named(args...; kwargs...)::Tuple{Vector{NamedCompletion},String,Bool}
-    result = complete_line(args...; kwargs...)::Union{Tuple{Vector{NamedCompletion},String,Bool},Tuple{Vector{String},String,Bool}}
-    if result isa Tuple{Vector{NamedCompletion},String,Bool}
-        return result
-    else
-        completions, partial, should_complete = result
-        return map(NamedCompletion, completions), partial, should_complete
-    end
+function complete_line_named(c, s, args...; kwargs...)::Tuple{Vector{NamedCompletion},Region,Bool}
+    r1, r2, should_complete = complete_line(c, s, args...; kwargs...)::Union{
+        Tuple{Vector{String}, String, Bool},
+        Tuple{Vector{NamedCompletion}, String, Bool},
+        Tuple{Vector{NamedCompletion}, Region, Bool},
+    }
+    completions = (r1 isa Vector{String} ? map(NamedCompletion, r1) : r1)
+    r = (r2 isa String ? (position(s)-sizeof(r2) => position(s)) : r2)
+    completions, r, should_complete
 end
 
 # checks for a hint and shows it if appropriate.
@@ -426,14 +431,14 @@ function check_show_hint(s::MIState)
         return
     end
     t_completion = Threads.@spawn :default begin
-        named_completions, partial, should_complete = nothing, nothing, nothing
+        named_completions, reg, should_complete = nothing, nothing, nothing
 
         # only allow one task to generate hints at a time and check around lock
         # if the user has pressed a key since the hint was requested, to skip old completions
         next_key_pressed() && return
         @lock s.hint_generation_lock begin
             next_key_pressed() && return
-            named_completions, partial, should_complete = try
+            named_completions, reg, should_complete = try
                 complete_line_named(st.p.complete, st, s.active_module; hint = true)
             catch
                 lock_clear_hint()
@@ -448,21 +453,19 @@ function check_show_hint(s::MIState)
             return
         end
         # Don't complete for single chars, given e.g. `x` completes to `xor`
-        if length(partial) > 1 && should_complete
+        if reg.second - reg.first > 1 && should_complete
             singlecompletion = length(completions) == 1
             p = singlecompletion ? completions[1] : common_prefix(completions)
             if singlecompletion || p in completions # i.e. complete `@time` even though `@time_imports` etc. exists
-                # The completion `p` and the input `partial` may not share the same initial
+                # The completion `p` and the region `reg` may not share the same initial
                 # characters, for instance when completing to subscripts or superscripts.
                 # So, in general, make sure that the hint starts at the correct position by
                 # incrementing its starting position by as many characters as the input.
-                startind = 1 # index of p from which to start providing the hint
-                maxind = ncodeunits(p)
-                for _ in partial
-                    startind = nextind(p, startind)
-                    startind > maxind && break
-                end
+                maxind = lastindex(p)
+                startind = sizeof(content(s, reg))
                 if startind ≤ maxind # completion on a complete name returns itself so check that there's something to hint
+                    # index of p from which to start providing the hint
+                    startind = nextind(p, startind)
                     hint = p[startind:end]
                     next_key_pressed() && return
                     @lock s.line_modify_lock begin
@@ -491,7 +494,7 @@ function clear_hint(s::ModeState)
 end
 
 function complete_line(s::PromptState, repeats::Int, mod::Module; hint::Bool=false)
-    completions, partial, should_complete = complete_line_named(s.p.complete, s, mod; hint)
+    completions, reg, should_complete = complete_line_named(s.p.complete, s, mod; hint)
     isempty(completions) && return false
     if !should_complete
         # should_complete is false for cases where we only want to show
@@ -499,17 +502,16 @@ function complete_line(s::PromptState, repeats::Int, mod::Module; hint::Bool=fal
         show_completions(s, completions)
     elseif length(completions) == 1
         # Replace word by completion
-        prev_pos = position(s)
         push_undo(s)
-        edit_splice!(s, (prev_pos - sizeof(partial)) => prev_pos, completions[1].completion)
+        edit_splice!(s, reg, completions[1].completion)
     else
         p = common_prefix(completions)
+        partial = content(s, reg.first => min(bufend(s), reg.first + sizeof(p)))
         if !isempty(p) && p != partial
             # All possible completions share the same prefix, so we might as
-            # well complete that
-            prev_pos = position(s)
+            # well complete that.
             push_undo(s)
-            edit_splice!(s, (prev_pos - sizeof(partial)) => prev_pos, p)
+            edit_splice!(s, reg, p)
         elseif repeats > 0
             show_completions(s, completions)
         end
@@ -830,12 +832,12 @@ function edit_move_right(m::MIState)
         refresh_line(s)
         return true
     else
-        completions, partial, should_complete = complete_line(s.p.complete, s, m.active_module)
-        if should_complete && eof(buf) && length(completions) == 1 && length(partial) > 1
+        completions, reg, should_complete = complete_line(s.p.complete, s, m.active_module)
+        if should_complete && eof(buf) && length(completions) == 1 && reg.second - reg.first > 1
             # Replace word by completion
             prev_pos = position(s)
             push_undo(s)
-            edit_splice!(s, (prev_pos - sizeof(partial)) => prev_pos, completions[1].completion)
+            edit_splice!(s, (prev_pos - reg.second + reg.first) => prev_pos, completions[1].completion)
             refresh_line(state(s))
             return true
         else
@@ -2255,12 +2257,12 @@ setmodifiers!(c) = nothing
 
 # Search Mode completions
 function complete_line(s::SearchState, repeats, mod::Module; hint::Bool=false)
-    completions, partial, should_complete = complete_line(s.histprompt.complete, s, mod; hint)
+    completions, reg, should_complete = complete_line(s.histprompt.complete, s, mod; hint)
     # For now only allow exact completions in search mode
     if length(completions) == 1
         prev_pos = position(s)
         push_undo(s)
-        edit_splice!(s, (prev_pos - sizeof(partial)) => prev_pos, completions[1].completion)
+        edit_splice!(s, (prev_pos - reg.second - reg.first) => prev_pos, completions[1].completion)
         return true
     end
     return false
diff --git a/stdlib/REPL/src/REPL.jl b/stdlib/REPL/src/REPL.jl
index ae2fec4ee10e0..cfb6e88a2663c 100644
--- a/stdlib/REPL/src/REPL.jl
+++ b/stdlib/REPL/src/REPL.jl
@@ -86,6 +86,7 @@ import .LineEdit:
     PromptState,
     mode_idx
 
+include("SyntaxUtil.jl")
 include("REPLCompletions.jl")
 using .REPLCompletions
 
@@ -799,27 +800,29 @@ end
 
 beforecursor(buf::IOBuffer) = String(buf.data[1:buf.ptr-1])
 
+# Convert inclusive-inclusive 1-based char indexing to inclusive-exclusive byte Region.
+to_region(s, r) = first(r)-1 => (length(r) > 0 ? nextind(s, last(r))-1 : first(r)-1)
+
 function complete_line(c::REPLCompletionProvider, s::PromptState, mod::Module; hint::Bool=false)
-    partial = beforecursor(s.input_buffer)
     full = LineEdit.input_string(s)
-    ret, range, should_complete = completions(full, lastindex(partial), mod, c.modifiers.shift, hint)
+    ret, range, should_complete = completions(full, thisind(full, position(s)), mod, c.modifiers.shift, hint)
+    range = to_region(full, range)
     c.modifiers = LineEdit.Modifiers()
-    return unique!(LineEdit.NamedCompletion[named_completion(x) for x in ret]), partial[range], should_complete
+    return unique!(LineEdit.NamedCompletion[named_completion(x) for x in ret]), range, should_complete
 end
 
 function complete_line(c::ShellCompletionProvider, s::PromptState; hint::Bool=false)
-    # First parse everything up to the current position
-    partial = beforecursor(s.input_buffer)
     full = LineEdit.input_string(s)
-    ret, range, should_complete = shell_completions(full, lastindex(partial), hint)
-    return unique!(LineEdit.NamedCompletion[named_completion(x) for x in ret]), partial[range], should_complete
+    ret, range, should_complete = shell_completions(full, thisind(full, position(s)), hint)
+    range = to_region(full, range)
+    return unique!(LineEdit.NamedCompletion[named_completion(x) for x in ret]), range, should_complete
 end
 
 function complete_line(c::LatexCompletions, s; hint::Bool=false)
-    partial = beforecursor(LineEdit.buffer(s))
     full = LineEdit.input_string(s)::String
-    ret, range, should_complete = bslash_completions(full, lastindex(partial), hint)[2]
-    return unique!(LineEdit.NamedCompletion[named_completion(x) for x in ret]), partial[range], should_complete
+    ret, range, should_complete = bslash_completions(full, thisind(full, position(s)), hint)[2]
+    range = to_region(full, range)
+    return unique!(LineEdit.NamedCompletion[named_completion(x) for x in ret]), range, should_complete
 end
 
 with_repl_linfo(f, repl) = f(outstream(repl))
diff --git a/stdlib/REPL/src/REPLCompletions.jl b/stdlib/REPL/src/REPLCompletions.jl
index d5a920efafe4e..8880fe9decb1e 100644
--- a/stdlib/REPL/src/REPLCompletions.jl
+++ b/stdlib/REPL/src/REPLCompletions.jl
@@ -12,8 +12,10 @@ const CC = Base.Compiler
 using Base.Meta
 using Base: propertynames, something, IdSet
 using Base.Filesystem: _readdirx
+using Base.JuliaSyntax: @K_str, @KSet_str, parseall, byte_range, children, is_prefix_call, is_trivia, kind
 
 using ..REPL.LineEdit: NamedCompletion
+using ..REPL.SyntaxUtil: CursorNode, find_parent, seek_pos, char_range, char_last, children_nt, find_delim
 
 abstract type Completion end
 
@@ -302,9 +304,8 @@ const sorted_keyvals = ["false", "true"]
 complete_keyval!(suggestions::Vector{Completion}, s::String) =
     complete_from_list!(suggestions, KeyvalCompletion, sorted_keyvals, s)
 
-function do_raw_escape(s)
-    # escape_raw_string with delim='`' and ignoring the rule for the ending \
-    return replace(s, r"(\\+)`" => s"\1\\`")
+function do_cmd_escape(s)
+    return Base.escape_raw_string(Base.shell_escape_posixly(s), '`')
 end
 function do_shell_escape(s)
     return Base.shell_escape_posixly(s)
@@ -312,6 +313,20 @@ end
 function do_string_escape(s)
     return escape_string(s, ('\"','$'))
 end
+function do_string_unescape(s)
+    s = replace(s, "\\\$"=>"\$")
+    try
+        unescape_string(s)
+    catch e
+        e isa ArgumentError || rethrow()
+        s # it is unlikely, but if it isn't a valid string, maybe it was a valid path, and just needs escape_string called?
+    end
+end
+
+function joinpath_withsep(dir, path; dirsep)
+    dir == "" && return path
+    dir[end] == dirsep ? dir * path : dir * dirsep * path
+end
 
 const PATH_cache_lock = Base.ReentrantLock()
 const PATH_cache = Set{String}()
@@ -409,9 +424,10 @@ end
 function complete_path(path::AbstractString;
                        use_envpath=false,
                        shell_escape=false,
-                       raw_escape=false,
+                       cmd_escape=false,
                        string_escape=false,
-                       contract_user=false)
+                       contract_user=false,
+                       dirsep=Sys.iswindows() ? '\\' : '/')
     @assert !(shell_escape && string_escape)
     if Base.Sys.isunix() && occursin(r"^~(?:/|$)", path)
         # if the path is just "~", don't consider the expanded username as a prefix
@@ -440,7 +456,7 @@ function complete_path(path::AbstractString;
     for entry in entries
         if startswith(entry.name, prefix)
             is_dir = try isdir(entry) catch ex; ex isa Base.IOError ? false : rethrow() end
-            push!(matches, is_dir ? entry.name * "/" : entry.name)
+            push!(matches, is_dir ? joinpath_withsep(entry.name, ""; dirsep) : entry.name)
         end
     end
 
@@ -456,7 +472,7 @@ function complete_path(path::AbstractString;
     end
 
     matches = ((shell_escape ? do_shell_escape(s) : string_escape ? do_string_escape(s) : s) for s in matches)
-    matches = ((raw_escape ? do_raw_escape(s) : s) for s in matches)
+    matches = ((cmd_escape ? do_cmd_escape(s) : s) for s in matches)
     matches = Completion[PathCompletion(contract_user ? contractuser(s) : s) for s in matches]
     return matches, dir, !isempty(matches)
 end
@@ -469,7 +485,8 @@ function complete_path(path::AbstractString,
                        contract_user=false)
     ## TODO: enable this depwarn once Pkg is fixed
     #Base.depwarn("complete_path with pos argument is deprecated because the return value [2] is incorrect to use", :complete_path)
-    paths, dir, success = complete_path(path; use_envpath, shell_escape, string_escape)
+    paths, dir, success = complete_path(path; use_envpath, shell_escape, string_escape, dirsep='/')
+
     if Base.Sys.isunix() && occursin(r"^~(?:/|$)", path)
         # if the path is just "~", don't consider the expanded username as a prefix
         if path == "~"
@@ -490,91 +507,6 @@ function complete_path(path::AbstractString,
     return paths, startpos:pos, success
 end
 
-function complete_expanduser(path::AbstractString, r)
-    expanded =
-        try expanduser(path)
-        catch e
-            e isa ArgumentError || rethrow()
-            path
-        end
-    return Completion[PathCompletion(expanded)], r, path != expanded
-end
-
-# Returns a range that includes the method name in front of the first non
-# closed start brace from the end of the string.
-function find_start_brace(s::AbstractString; c_start='(', c_end=')')
-    r = reverse(s)
-    i = firstindex(r)
-    braces = in_comment = 0
-    in_single_quotes = in_double_quotes = in_back_ticks = false
-    num_single_quotes_in_string = count('\'', s)
-    while i <= ncodeunits(r)
-        c, i = iterate(r, i)
-        if c == '#' && i <= ncodeunits(r) && iterate(r, i)[1] == '='
-            c, i = iterate(r, i) # consume '='
-            new_comments = 1
-            # handle #=#=#=#, by counting =# pairs
-            while i <= ncodeunits(r) && iterate(r, i)[1] == '#'
-                c, i = iterate(r, i) # consume '#'
-                iterate(r, i)[1] == '=' || break
-                c, i = iterate(r, i) # consume '='
-                new_comments += 1
-            end
-            if c == '='
-                in_comment += new_comments
-            else
-                in_comment -= new_comments
-            end
-        elseif !in_single_quotes && !in_double_quotes && !in_back_ticks && in_comment == 0
-            if c == c_start
-                braces += 1
-            elseif c == c_end
-                braces -= 1
-            elseif c == '\'' && num_single_quotes_in_string % 2 == 0
-                # ' can be a transpose too, so check if there are even number of 's in the string
-                # TODO: This probably needs to be more robust
-                in_single_quotes = true
-            elseif c == '"'
-                in_double_quotes = true
-            elseif c == '`'
-                in_back_ticks = true
-            end
-        else
-            if in_single_quotes &&
-                c == '\'' && i <= ncodeunits(r) && iterate(r, i)[1] != '\\'
-                in_single_quotes = false
-            elseif in_double_quotes &&
-                c == '"' && i <= ncodeunits(r) && iterate(r, i)[1] != '\\'
-                in_double_quotes = false
-            elseif in_back_ticks &&
-                c == '`' && i <= ncodeunits(r) && iterate(r, i)[1] != '\\'
-                in_back_ticks = false
-            elseif in_comment > 0 &&
-                c == '=' && i <= ncodeunits(r) && iterate(r, i)[1] == '#'
-                # handle =#=#=#=, by counting #= pairs
-                c, i = iterate(r, i) # consume '#'
-                old_comments = 1
-                while i <= ncodeunits(r) && iterate(r, i)[1] == '='
-                    c, i = iterate(r, i) # consume '='
-                    iterate(r, i)[1] == '#' || break
-                    c, i = iterate(r, i) # consume '#'
-                    old_comments += 1
-                end
-                if c == '#'
-                    in_comment -= old_comments
-                else
-                    in_comment += old_comments
-                end
-            end
-        end
-        braces == 1 && break
-    end
-    braces != 1 && return 0:-1, -1
-    method_name_end = reverseind(s, i)
-    startind = nextind(s, something(findprev(in(non_identifier_chars), s, method_name_end), 0))::Int
-    return (startind:lastindex(s), method_name_end)
-end
-
 struct REPLCacheToken end
 
 struct REPLInterpreter <: CC.AbstractInterpreter
@@ -729,6 +661,7 @@ end
 
 # lower `ex` and run type inference on the resulting top-level expression
 function repl_eval_ex(@nospecialize(ex), context_module::Module; limit_aggressive_inference::Bool=false)
+    expr_has_error(ex) && return nothing
     if (isexpr(ex, :toplevel) || isexpr(ex, :tuple)) && !isempty(ex.args)
         # get the inference result for the last expression
         ex = ex.args[end]
@@ -778,6 +711,7 @@ code_typed(CC.typeinf, (REPLInterpreter, CC.InferenceState))
 # Method completion on function call expression that look like :(max(1))
 MAX_METHOD_COMPLETIONS::Int = 40
 function _complete_methods(ex_org::Expr, context_module::Module, shift::Bool)
+    isempty(ex_org.args) && return 2, nothing, [], Set{Symbol}()
     funct = repl_eval_ex(ex_org.args[1], context_module)
     funct === nothing && return 2, nothing, [], Set{Symbol}()
     funct = CC.widenconst(funct)
@@ -935,50 +869,6 @@ const subscript_regex = Regex("^\\\\_[" * join(isdigit(k) || isletter(k) ? "$k"
 const superscripts = Dict(k[3]=>v[1] for (k,v) in latex_symbols if startswith(k, "\\^") && length(k)==3)
 const superscript_regex = Regex("^\\\\\\^[" * join(isdigit(k) || isletter(k) ? "$k" : "\\$k" for k in keys(superscripts)) * "]+\\z")
 
-# Aux function to detect whether we're right after a using or import keyword
-function get_import_mode(s::String)
-    # allow all of these to start with leading whitespace and macros like @eval and @eval(
-    # ^\s*(?:@\w+\s*(?:\(\s*)?)?
-
-    # match simple cases like `using |` and `import  |`
-    mod_import_match_simple = match(r"^\s*(?:@\w+\s*(?:\(\s*)?)?\b(using|import)\s*$", s)
-    if mod_import_match_simple !== nothing
-        if mod_import_match_simple[1] == "using"
-            return :using_module
-        else
-            return :import_module
-        end
-    end
-    # match module import statements like `using Foo|`, `import Foo, Bar|` and `using Foo.Bar, Baz, |`
-    mod_import_match = match(r"^\s*(?:@\w+\s*(?:\(\s*)?)?\b(using|import)\s+([\w\.]+(?:\s*,\s*[\w\.]+)*),?\s*$", s)
-    if mod_import_match !== nothing
-        if mod_import_match.captures[1] == "using"
-            return :using_module
-        else
-            return :import_module
-        end
-    end
-    # now match explicit name import statements like `using Foo: |` and `import Foo: bar, baz|`
-    name_import_match = match(r"^\s*(?:@\w+\s*(?:\(\s*)?)?\b(using|import)\s+([\w\.]+)\s*:\s*([\w@!\s,]+)$", s)
-    if name_import_match !== nothing
-        if name_import_match[1] == "using"
-            return :using_name
-        else
-            return :import_name
-        end
-    end
-    return nothing
-end
-
-function close_path_completion(dir, path, str, pos)
-    path = unescape_string(replace(path, "\\\$"=>"\$"))
-    path = joinpath(dir, path)
-    # ...except if it's a directory...
-    Base.isaccessibledir(path) && return false
-    # ...and except if there's already a " at the cursor.
-    return lastindex(str) <= pos || str[nextind(str, pos)] != '"'
-end
-
 function bslash_completions(string::String, pos::Int, hint::Bool=false)
     slashpos = something(findprev(isequal('\\'), string, pos), 0)
     if (something(findprev(in(bslash_separators), string, pos), 0) < slashpos &&
@@ -1006,29 +896,7 @@ function bslash_completions(string::String, pos::Int, hint::Bool=false)
         completions = Completion[BslashCompletion(name, "$(symbol_dict[name]) $name") for name in sort!(collect(namelist))]
         return (true, (completions, slashpos:pos, true))
     end
-    return (false, (Completion[], 0:-1, false))
-end
-
-function dict_identifier_key(str::String, tag::Symbol, context_module::Module=Main)
-    if tag === :string
-        str_close = str*"\""
-    elseif tag === :cmd
-        str_close = str*"`"
-    else
-        str_close = str
-    end
-    frange, end_of_identifier = find_start_brace(str_close, c_start='[', c_end=']')
-    isempty(frange) && return (nothing, nothing, nothing)
-    objstr = str[1:end_of_identifier]
-    objex = Meta.parse(objstr, raise=false, depwarn=false)
-    objt = repl_eval_ex(objex, context_module)
-    isa(objt, Core.Const) || return (nothing, nothing, nothing)
-    obj = objt.val
-    isa(obj, AbstractDict) || return (nothing, nothing, nothing)
-    (Base.haslength(obj) && length(obj)::Int < 1_000_000) || return (nothing, nothing, nothing)
-    begin_of_key = something(findnext(!isspace, str, nextind(str, end_of_identifier) + 1), # +1 for [
-                             lastindex(str)+1)
-    return (obj, str[begin_of_key:end], begin_of_key)
+    return (false, (Completion[], 1:0, false))
 end
 
 # This needs to be a separate non-inlined function, see #19441
@@ -1041,45 +909,12 @@ end
     return matches
 end
 
-# Identify an argument being completed in a method call. If the argument is empty, method
-# suggestions will be provided instead of argument completions.
-function identify_possible_method_completion(partial, last_idx)
-    fail = 0:-1, Expr(:nothing), 0:-1, 0
-
-    # First, check that the last punctuation is either ',', ';' or '('
-    idx_last_punct = something(findprev(x -> ispunct(x) && x != '_' && x != '!', partial, last_idx), 0)::Int
-    idx_last_punct == 0 && return fail
-    last_punct = partial[idx_last_punct]
-    last_punct == ',' || last_punct == ';' || last_punct == '(' || return fail
-
-    # Then, check that `last_punct` is only followed by an identifier or nothing
-    before_last_word_start = something(findprev(in(non_identifier_chars), partial, last_idx), 0)
-    before_last_word_start == 0 && return fail
-    all(isspace, @view partial[nextind(partial, idx_last_punct):before_last_word_start]) || return fail
-
-    # Check that `last_punct` is either the last '(' or placed after a previous '('
-    frange, method_name_end = find_start_brace(@view partial[1:idx_last_punct])
-    method_name_end ∈ frange || return fail
-
-    # Strip the preceding ! operators, if any, and close the expression with a ')'
-    s = replace(partial[frange], r"\G\!+([^=\(]+)" => s"\1"; count=1) * ')'
-    ex = Meta.parse(s, raise=false, depwarn=false)
-    isa(ex, Expr) || return fail
-
-    # `wordrange` is the position of the last argument to complete
-    wordrange = nextind(partial, before_last_word_start):last_idx
-    return frange, ex, wordrange, method_name_end
-end
-
 # Provide completion for keyword arguments in function calls
-function complete_keyword_argument(partial::String, last_idx::Int, context_module::Module;
-                                   shift::Bool=false)
-    frange, ex, wordrange, = identify_possible_method_completion(partial, last_idx)
-    fail = Completion[], 0:-1, frange
-    ex.head === :call || is_broadcasting_expr(ex) || return fail
-
+function complete_keyword_argument!(suggestions::Vector{Completion},
+                                    ex::Expr, last_word::String,
+                                    context_module::Module; shift::Bool=false)
     kwargs_flag, funct, args_ex, kwargs_ex = _complete_methods(ex, context_module, true)::Tuple{Int, Any, Vector{Any}, Set{Symbol}}
-    kwargs_flag == 2 && return fail # one of the previous kwargs is invalid
+    kwargs_flag == 2 && false # one of the previous kwargs is invalid
 
     methods = Completion[]
     complete_methods!(methods, funct, Any[Vararg{Any}], kwargs_ex, shift ? -1 : MAX_METHOD_COMPLETIONS, kwargs_flag == 1)
@@ -1091,7 +926,6 @@ function complete_keyword_argument(partial::String, last_idx::Int, context_modul
     # previously in the expression. The corresponding suggestion is "kwname=".
     # If the keyword corresponds to an existing name, also include "kwname" as a suggestion
     # since the syntax "foo(; kwname)" is equivalent to "foo(; kwname=kwname)".
-    last_word = partial[wordrange] # the word to complete
     kwargs = Set{String}()
     for m in methods
         # if MAX_METHOD_COMPLETIONS is hit a single TextCompletion is return by complete_methods! with an explanation
@@ -1102,22 +936,18 @@ function complete_keyword_argument(partial::String, last_idx::Int, context_modul
         current_kwarg_candidates = String[]
         for _kw in possible_kwargs
             kw = String(_kw)
-            if !endswith(kw, "...") && startswith(kw, last_word) && _kw ∉ kwargs_ex
+            # HACK: Should consider removing current arg from AST.
+            if !endswith(kw, "...") && startswith(kw, last_word) && (_kw ∉ kwargs_ex || kw == last_word)
                 push!(current_kwarg_candidates, kw)
             end
         end
         union!(kwargs, current_kwarg_candidates)
     end
 
-    suggestions = Completion[KeywordArgumentCompletion(kwarg) for kwarg in kwargs]
-
-    # Only add these if not in kwarg space. i.e. not in `foo(; `
-    if kwargs_flag == 0
-        complete_symbol!(suggestions, #=prefix=#nothing, last_word, context_module; shift)
-        complete_keyval!(suggestions, last_word)
+    for kwarg in kwargs
+        push!(suggestions, KeywordArgumentCompletion(kwarg))
     end
-
-    return sort!(suggestions, by=named_completion_completion), wordrange
+    return kwargs_flag != 0
 end
 
 function get_loading_candidates(pkgstarts::String, project_file::String)
@@ -1136,411 +966,367 @@ function get_loading_candidates(pkgstarts::String, project_file::String)
     return loading_candidates
 end
 
-function complete_loading_candidates!(suggestions::Vector{Completion}, pkgstarts::String, project_file::String)
-    for name in get_loading_candidates(pkgstarts, project_file)
-        push!(suggestions, PackageCompletion(name))
+function complete_loading_candidates!(suggestions::Vector{Completion}, s::String)
+    for name in ("Core", "Base")
+        startswith(name, s) && push!(suggestions, PackageCompletion(name))
     end
-    return suggestions
-end
 
-function complete_identifiers!(suggestions::Vector{Completion},
-                               context_module::Module, string::String, name::String,
-                               pos::Int, separatorpos::Int, startpos::Int;
-                               comp_keywords::Bool=false,
-                               complete_modules_only::Bool=false,
-                               shift::Bool=false)
-    if comp_keywords
-        complete_keyword!(suggestions, name)
-        complete_keyval!(suggestions, name)
-    end
-    if separatorpos > 1 && (string[separatorpos] == '.' || string[separatorpos] == ':')
-        s = string[1:prevind(string, separatorpos)]
-        # First see if the whole string up to `pos` is a valid expression. If so, use it.
-        prefix = Meta.parse(s, raise=false, depwarn=false)
-        if isexpr(prefix, :incomplete)
-            s = string[startpos:pos]
-            # Heuristic to find the start of the expression. TODO: This would be better
-            # done with a proper error-recovering parser.
-            if 0 < startpos <= lastindex(string) && string[startpos] == '.'
-                i = prevind(string, startpos)
-                while 0 < i
-                    c = string[i]
-                    if c in (')', ']')
-                        if c == ')'
-                            c_start = '('
-                            c_end = ')'
-                        elseif c == ']'
-                            c_start = '['
-                            c_end = ']'
-                        end
-                        frange, end_of_identifier = find_start_brace(string[1:prevind(string, i)], c_start=c_start, c_end=c_end)
-                        isempty(frange) && break # unbalanced parens
-                        startpos = first(frange)
-                        i = prevind(string, startpos)
-                    elseif c in ('\'', '\"', '\`')
-                        s = "$c$c"*string[startpos:pos]
-                        break
+    # If there's no dot, we're in toplevel, so we should
+    # also search for packages
+    for dir in Base.load_path()
+        if basename(dir) in Base.project_names && isfile(dir)
+            for name in get_loading_candidates(s, dir)
+                push!(suggestions, PackageCompletion(name))
+            end
+        end
+        isdir(dir) || continue
+        for entry in _readdirx(dir)
+            pname = entry.name
+            if pname[1] != '.' && pname != "METADATA" &&
+                pname != "REQUIRE" && startswith(pname, s)
+                # Valid file paths are
+                #   <Mod>.jl
+                #   <Mod>/src/<Mod>.jl
+                #   <Mod>.jl/src/<Mod>.jl
+                if isfile(entry)
+                    endswith(pname, ".jl") && push!(suggestions,
+                                                    PackageCompletion(pname[1:prevind(pname, end-2)]))
+                else
+                    mod_name = if endswith(pname, ".jl")
+                        pname[1:prevind(pname, end-2)]
                     else
-                        break
+                        pname
                     end
-                    s = string[startpos:pos]
-                end
-            end
-            if something(findlast(in(non_identifier_chars), s), 0) < something(findlast(isequal('.'), s), 0)
-                lookup_name, name = rsplit(s, ".", limit=2)
-                name = String(name)
-                prefix = Meta.parse(lookup_name, raise=false, depwarn=false)
-            end
-            isexpr(prefix, :incomplete) && (prefix = nothing)
-        elseif isexpr(prefix, (:using, :import))
-            arglast = prefix.args[end] # focus on completion to the last argument
-            if isexpr(arglast, :.)
-                # We come here for cases like:
-                # - `string`: "using Mod1.Mod2.M"
-                # - `ex`: :(using Mod1.Mod2)
-                # - `name`: "M"
-                # Now we transform `ex` to `:(Mod1.Mod2)` to allow `complete_symbol!` to
-                # complete for inner modules whose name starts with `M`.
-                # Note that `complete_modules_only=true` is set within `completions`
-                prefix = nothing
-                firstdot = true
-                for arg = arglast.args
-                    if arg === :.
-                        # override `context_module` if multiple `.` accessors are used
-                        if firstdot
-                            firstdot = false
-                        else
-                            context_module = parentmodule(context_module)
-                        end
-                    elseif arg isa Symbol
-                        if prefix === nothing
-                            prefix = arg
-                        else
-                            prefix = Expr(:., prefix, QuoteNode(arg))
-                        end
-                    else # invalid expression
-                        prefix = nothing
-                        break
+                    if isfile(joinpath(entry, "src",
+                                       "$mod_name.jl"))
+                        push!(suggestions, PackageCompletion(mod_name))
                     end
                 end
             end
-        elseif isexpr(prefix, :call) && length(prefix.args) > 1
-            isinfix = s[end] != ')'
-            # A complete call expression that does not finish with ')' is an infix call.
-            if !isinfix
-                # Handle infix call argument completion of the form bar + foo(qux).
-                frange, end_of_identifier = find_start_brace(@view s[1:prevind(s, end)])
-                if !isempty(frange) # if find_start_brace fails to find the brace just continue
-                    isinfix = Meta.parse(@view(s[frange[1]:end]), raise=false, depwarn=false) == prefix.args[end]
-                end
-            end
-            if isinfix
-                prefix = prefix.args[end]
-            end
-        elseif isexpr(prefix, :macrocall) && length(prefix.args) > 1
-            # allow symbol completions within potentially incomplete macrocalls
-            if s[end] ≠ '`' && s[end] ≠ ')'
-                prefix = prefix.args[end]
-            end
         end
-    else
-        prefix = nothing
     end
-    complete_symbol!(suggestions, prefix, name, context_module; complete_modules_only, shift)
-    return suggestions
 end
 
 function completions(string::String, pos::Int, context_module::Module=Main, shift::Bool=true, hint::Bool=false)
-    # First parse everything up to the current position
-    partial = string[1:pos]
-    inc_tag = Base.incomplete_tag(Meta.parse(partial, raise=false, depwarn=false))
-
-    if !hint # require a tab press for completion of these
-        # ?(x, y)TAB lists methods you can call with these objects
-        # ?(x, y TAB lists methods that take these objects as the first two arguments
-        # MyModule.?(x, y)TAB restricts the search to names in MyModule
-        rexm = match(r"(\w+\.|)\?\((.*)$", partial)
-        if rexm !== nothing
-            # Get the module scope
-            if isempty(rexm.captures[1])
-                callee_module = context_module
-            else
-                modname = Symbol(rexm.captures[1][1:end-1])
-                if isdefined(context_module, modname)
-                    callee_module = getfield(context_module, modname)
-                    if !isa(callee_module, Module)
-                        callee_module = context_module
-                    end
-                else
-                    callee_module = context_module
-                end
-            end
-            moreargs = !endswith(rexm.captures[2], ')')
-            callstr = "_(" * rexm.captures[2]
-            if moreargs
-                callstr *= ')'
-            end
-            ex_org = Meta.parse(callstr, raise=false, depwarn=false)
-            if isa(ex_org, Expr)
-                return complete_any_methods(ex_org, callee_module::Module, context_module, moreargs, shift), (0:length(rexm.captures[1])+1) .+ rexm.offset, false
-            end
-        end
-    end
+    # filename needs to be string so macro can be evaluated
+    node = parseall(CursorNode, string, ignore_errors=true, keep_parens=true, filename="none")
+    cur = @something seek_pos(node, pos) node
 
-    # if completing a key in a Dict
-    identifier, partial_key, loc = dict_identifier_key(partial, inc_tag, context_module)
-    if identifier !== nothing
-        matches = find_dict_matches(identifier, partial_key)
-        length(matches)==1 && (lastindex(string) <= pos || string[nextind(string,pos)] != ']') && (matches[1]*=']')
-        length(matches)>0 && return Completion[DictCompletion(identifier, match) for match in sort!(matches)], loc::Int:pos, true
-    end
+    # Back up before whitespace to get a more useful AST node.
+    pos_not_ws = findprev(!isspace, string, pos)
+    cur_not_ws = something(seek_pos(node, pos_not_ws), node)
 
     suggestions = Completion[]
+    sort_suggestions() = sort!(unique!(named_completion, suggestions), by=named_completion_completion)
+
+    # Search for methods (requires tab press):
+    #   ?(x, y)TAB           lists methods you can call with these objects
+    #   ?(x, y TAB           lists methods that take these objects as the first two arguments
+    #   MyModule.?(x, y)TAB  restricts the search to names in MyModule
+    if !hint
+        cs = method_search(view(string, 1:pos), context_module, shift)
+        cs !== nothing && return cs
+    end
 
-    # Check if this is a var"" string macro that should be completed like
-    # an identifier rather than a string.
-    # TODO: It would be nice for the parser to give us more information here
-    # so that we can lookup the macro by identity rather than pattern matching
-    # its invocation.
-    varrange = findprev("var\"", string, pos)
-
-    expanded = nothing
-    was_expanded = false
-
-    if varrange !== nothing
-        ok, ret = bslash_completions(string, pos)
-        ok && return ret
-        startpos = first(varrange) + 4
-        separatorpos = something(findprev(isequal('.'), string, first(varrange)-1), 0)
-        name = string[startpos:pos]
-        complete_identifiers!(suggestions, context_module, string, name,
-                              pos, separatorpos, startpos;
-                              shift)
-        return sort!(unique!(named_completion, suggestions), by=named_completion_completion), (separatorpos+1):pos, true
-    elseif inc_tag === :cmd
-        # TODO: should this call shell_completions instead of partially reimplementing it?
-        let m = match(r"[\t\n\r\"`><=*?|]| (?!\\)", reverse(partial)) # fuzzy shell_parse in reverse
-            startpos = nextind(partial, reverseind(partial, m.offset))
-            r = startpos:pos
-            scs::String = string[r]
-
-            expanded = complete_expanduser(scs, r)
-            was_expanded = expanded[3]
-            if was_expanded
-                scs = (only(expanded[1])::PathCompletion).path
-                # If tab press, ispath and user expansion available, return it now
-                # otherwise see if we can complete the path further before returning with expanded ~
-                !hint && ispath(scs) && return expanded::Completions
-            end
-
-            path::String = replace(scs, r"(\\+)\g1(\\?)`" => "\1\2`") # fuzzy unescape_raw_string: match an even number of \ before ` and replace with half as many
-            # This expansion with "\\ "=>' ' replacement and shell_escape=true
-            # assumes the path isn't further quoted within the cmd backticks.
-            path = replace(path, r"\\ " => " ", r"\$" => "\$") # fuzzy shell_parse (reversed by shell_escape_posixly)
-            paths, dir, success = complete_path(path, shell_escape=true, raw_escape=true)
-
-            if success && !isempty(dir)
-                let dir = do_raw_escape(do_shell_escape(dir))
-                    # if escaping of dir matches scs prefix, remove that from the completions
-                    # otherwise make it the whole completion
-                    if endswith(dir, "/") && startswith(scs, dir)
-                        r = (startpos + sizeof(dir)):pos
-                    elseif startswith(scs, dir * "/")
-                        r = nextind(string, startpos + sizeof(dir)):pos
-                    else
-                        map!(paths, paths) do c::PathCompletion
-                            p = dir * "/" * c.path
-                            was_expanded && (p = contractuser(p))
-                            return PathCompletion(p)
-                        end
-                    end
-                end
-            end
-            if isempty(paths) && !hint && was_expanded
-                # if not able to provide completions, not hinting, and ~ expansion was possible, return ~ expansion
-                return expanded::Completions
-            else
-                return sort!(paths, by=p->p.path), r::UnitRange{Int}, success
+    # Complete keys in a Dict:
+    #   my_dict[ TAB
+    n, key, closed = find_ref_key(cur_not_ws, pos)
+    if n !== nothing
+        key::UnitRange{Int}
+        obj = dict_eval(Expr(n), context_module)
+        if obj !== nothing
+            # Skip leading whitespace inside brackets.
+            i = @something findnext(!isspace, string, first(key)) nextind(string, last(key))
+            key = i:last(key)
+            s = string[intersect(key, 1:pos)]
+            matches = find_dict_matches(obj, s)
+            length(matches) == 1 && !closed && (matches[1] *= ']')
+            if length(matches) > 0
+                ret = Completion[DictCompletion(obj, match) for match in sort!(matches)]
+                return ret, key, true
             end
         end
-    elseif inc_tag === :string
-        # Find first non-escaped quote
-        let m = match(r"\"(?!\\)", reverse(partial))
-            startpos = nextind(partial, reverseind(partial, m.offset))
-            r = startpos:pos
-            scs::String = string[r]
-
-            expanded = complete_expanduser(scs, r)
-            was_expanded = expanded[3]
-            if was_expanded
-                scs = (only(expanded[1])::PathCompletion).path
-                # If tab press, ispath and user expansion available, return it now
-                # otherwise see if we can complete the path further before returning with expanded ~
-                !hint && ispath(scs) && return expanded::Completions
-            end
-
-            path = try
-                unescape_string(replace(scs, "\\\$"=>"\$"))
-            catch ex
-                ex isa ArgumentError || rethrow()
-                nothing
-            end
-            if !isnothing(path)
-                paths, dir, success = complete_path(path::String, string_escape=true)
-
-                if length(paths) == 1
-                    p = (paths[1]::PathCompletion).path
-                    hint && was_expanded && (p = contractuser(p))
-                    if close_path_completion(dir, p, path, pos)
-                        paths[1] = PathCompletion(p * "\"")
-                    end
-                end
+    end
 
-                if success && !isempty(dir)
-                    let dir = do_string_escape(dir)
-                        # if escaping of dir matches scs prefix, remove that from the completions
-                        # otherwise make it the whole completion
-                        if endswith(dir, "/") && startswith(scs, dir)
-                            r = (startpos + sizeof(dir)):pos
-                        elseif startswith(scs, dir * "/") && dir != dirname(homedir())
-                            was_expanded && (dir = contractuser(dir))
-                            r = nextind(string, startpos + sizeof(dir)):pos
-                        else
-                            map!(paths, paths) do c::PathCompletion
-                                p = dir * "/" * c.path
-                                hint && was_expanded && (p = contractuser(p))
-                                return PathCompletion(p)
-                            end
-                        end
-                    end
-                end
+    # Complete Cmd strings:
+    #   `fil TAB                 => `file
+    #   `file ~/exa TAB          => `file ~/example.txt
+    #   `file ~/example.txt TAB  => `file /home/user/example.txt
+    if (n = find_parent(cur, K"CmdString")) !== nothing
+        off = n.position - 1
+        ret, r, success = shell_completions(string[char_range(n)], pos - off, hint, cmd_escape=true)
+        success && return ret, r .+ off, success
+    end
 
-                # Fallthrough allowed so that Latex symbols can be completed in strings
-                if success
-                    return sort!(paths, by=p->p.path), r::UnitRange{Int}, success
-                elseif !hint && was_expanded
-                    # if not able to provide completions, not hinting, and ~ expansion was possible, return ~ expansion
-                    return expanded::Completions
-                end
-            end
+    # Complete ordinary strings:
+    #  "~/exa TAB         => "~/example.txt"
+    #  "~/example.txt TAB => "/home/user/example.txt"
+    r, closed = find_str(cur)
+    if r !== nothing
+        s = do_string_unescape(string[r])
+        ret, success = complete_path_string(s, hint; string_escape=true,
+                                            dirsep=Sys.iswindows() ? '\\' : '/')
+        if length(ret) == 1 && !closed && close_path_completion(ret[1].path)
+            ret[1] = PathCompletion(ret[1].path * '"')
         end
+        success && return ret, r, success
     end
-    # if path has ~ and we didn't find any paths to complete just return the expanded path
-    was_expanded && return expanded::Completions
 
+    # Backlash symbols:
+    #   \pi => π
+    # Comes after string completion so backslash escapes are not misinterpreted.
     ok, ret = bslash_completions(string, pos)
     ok && return ret
 
-    # Make sure that only bslash_completions is working on strings
-    inc_tag === :string && return Completion[], 0:-1, false
-    if inc_tag === :other
-        frange, ex, wordrange, method_name_end = identify_possible_method_completion(partial, pos)
-        if last(frange) != -1 && all(isspace, @view partial[wordrange]) # no last argument to complete
-            if ex.head === :call
-                return complete_methods(ex, context_module, shift), first(frange):method_name_end, false
-            elseif is_broadcasting_expr(ex)
-                return complete_methods(ex, context_module, shift), first(frange):(method_name_end - 1), false
-            end
+    # Don't fall back to symbol completion inside strings or comments.
+    inside_cmdstr = find_parent(cur, K"cmdstring") !== nothing
+    (kind(cur) in KSet"String Comment ErrorEofMultiComment" || inside_cmdstr) &&
+         return Completion[], 1:0, false
+
+    if (n = find_prefix_call(cur_not_ws)) !== nothing
+        func = first(children_nt(n))
+        e = Expr(n)
+        # Remove arguments past the first parse error (allows unclosed parens)
+        if is_broadcasting_expr(e)
+            i = findfirst(x -> x isa Expr && x.head == :error, e.args[2].args)
+            i !== nothing && deleteat!(e.args[2].args, i:lastindex(e.args[2].args))
+        else
+            i = findfirst(x -> x isa Expr && x.head == :error, e.args)
+            i !== nothing && deleteat!(e.args, i:lastindex(e.args))
         end
-    elseif inc_tag === :comment
-        return Completion[], 0:-1, false
-    end
 
-    # Check whether we can complete a keyword argument in a function call
-    kwarg_completion, wordrange = complete_keyword_argument(partial, pos, context_module; shift)
-    isempty(wordrange) || return kwarg_completion, wordrange, !isempty(kwarg_completion)
+        # Method completion:
+        #   foo( TAB     => list of method signatures for foo
+        #   foo(x, TAB   => list of methods signatures for foo with x as first argument
+        if kind(cur_not_ws) in KSet"( , ;"
+            # Don't provide method completions unless the cursor is after: '(' ',' ';'
+            return complete_methods(e, context_module, shift), char_range(func), false
+
+        # Keyword argument completion:
+        #   foo(ar TAB   => keyword arguments like `arg1=`
+        elseif kind(cur) == K"Identifier"
+            r = char_range(cur)
+            s = string[intersect(r, 1:pos)]
+            # Return without adding more suggestions if kwargs only
+            complete_keyword_argument!(suggestions, e, s, context_module; shift) &&
+                return sort_suggestions(), r, true
+        end
+    end
 
-    startpos = nextind(string, something(findprev(in(non_identifier_chars), string, pos), 0))
-    # strip preceding ! operator
-    if (m = match(r"\G\!+", partial, startpos)) isa RegexMatch
-        startpos += length(m.match)
+    # Symbol completion
+    # TODO: Should completions replace the identifier at the cursor?
+    if cur.parent !== nothing && kind(cur.parent) == K"var"
+        # Replace the entire var"foo", but search using only "foo".
+        r = intersect(char_range(cur.parent), 1:pos)
+        r2 = char_range(children_nt(cur.parent)[1])
+        s = string[intersect(r2, 1:pos)]
+    elseif kind(cur) in KSet"Identifier @"
+        r = intersect(char_range(cur), 1:pos)
+        s = string[r]
+    elseif kind(cur) == K"MacroName"
+        # Include the `@`
+        r = intersect(prevind(string, cur.position):char_last(cur), 1:pos)
+        s = string[r]
+    else
+        r = nextind(string, pos):pos
+        s = ""
     end
 
-    separatorpos = something(findprev(isequal('.'), string, pos), 0)
-    namepos = max(startpos, separatorpos+1)
-    name = string[namepos:pos]
-    import_mode = get_import_mode(string)
-    if import_mode === :using_module || import_mode === :import_module
+    complete_modules_only = false
+    prefix = node_prefix(cur, context_module)
+    comp_keywords = prefix === nothing
+
+    # Complete loadable module names:
+    #   import Mod TAB
+    #   import Mod1, Mod2 TAB
+    #   using Mod TAB
+    if (n = find_parent(cur, K"importpath")) !== nothing
         # Given input lines like `using Foo|`, `import Foo, Bar|` and `using Foo.Bar, Baz, |`:
         # Let's look only for packages and modules we can reach from here
-
-        # If there's no dot, we're in toplevel, so we should
-        # also search for packages
-        s = string[startpos:pos]
-        if separatorpos <= startpos
-            for dir in Base.load_path()
-                if basename(dir) in Base.project_names && isfile(dir)
-                    complete_loading_candidates!(suggestions, s, dir)
-                end
-                isdir(dir) || continue
-                for entry in _readdirx(dir)
-                    pname = entry.name
-                    if pname[1] != '.' && pname != "METADATA" &&
-                        pname != "REQUIRE" && startswith(pname, s)
-                        # Valid file paths are
-                        #   <Mod>.jl
-                        #   <Mod>/src/<Mod>.jl
-                        #   <Mod>.jl/src/<Mod>.jl
-                        if isfile(entry)
-                            endswith(pname, ".jl") && push!(suggestions,
-                                                            PackageCompletion(pname[1:prevind(pname, end-2)]))
-                        else
-                            mod_name = if endswith(pname, ".jl")
-                                pname[1:prevind(pname, end-2)]
-                            else
-                                pname
-                            end
-                            if isfile(joinpath(entry, "src",
-                                               "$mod_name.jl"))
-                                push!(suggestions, PackageCompletion(mod_name))
-                            end
-                        end
-                    end
-                end
-            end
+        if prefix == nothing
+            complete_loading_candidates!(suggestions, s)
+            return sort_suggestions(), r, true
         end
+
+        # Allow completion for `import Mod.name` (where `name` is not a module)
+        complete_modules_only = prefix == nothing || kind(n.parent) == K"using"
         comp_keywords = false
-        complete_modules_only = import_mode === :using_module # allow completion for `import Mod.name` (where `name` is not a module)
-    elseif import_mode === :using_name || import_mode === :import_name
-        # `using Foo: |` and `import Foo: bar, baz|`
-        separatorpos = findprev(isequal(':'), string, pos)::Int
-        comp_keywords = false
-        complete_modules_only = false
+    end
+
+    if comp_keywords
+        complete_keyword!(suggestions, s)
+        complete_keyval!(suggestions, s)
+    end
+
+    complete_symbol!(suggestions, prefix, s, context_module; complete_modules_only, shift)
+    return sort_suggestions(), r, true
+end
+
+function close_path_completion(path)
+    path = expanduser(path)
+    path = do_string_unescape(path)
+    !Base.isaccessibledir(path)
+end
+
+# Lowering can misbehave with nested error expressions.
+function expr_has_error(@nospecialize(e))
+    e isa Expr || return false
+    e.head === :error &&  return true
+    any(expr_has_error, e.args)
+end
+
+# Is the cursor inside the square brackets of a ref expression?  If so, returns:
+# - The ref node
+# - The range of characters for the brackets
+# - A flag indicating if the closing bracket is present
+function find_ref_key(cur::CursorNode, pos::Int)
+    n = find_parent(cur, K"ref")
+    n !== nothing || return nothing, nothing, nothing
+    key, closed = find_delim(n, K"[", K"]")
+    first(key) - 1 <= pos <= last(key) || return nothing, nothing, nothing
+    n, key, closed
+end
+
+# If the cursor is in a literal string, return the contents and char range
+# inside the quotes.  Ignores triple strings.
+function find_str(cur::CursorNode)
+    n = find_parent(cur, K"string")
+    n !== nothing || return nothing, nothing
+    find_delim(n, K"\"", K"\"")
+end
+
+# Is the cursor directly inside of the arguments of a prefix call (no nested
+# expressions)?
+function find_prefix_call(cur::CursorNode)
+    n = cur.parent
+    n !== nothing || return nothing
+    is_call(n) = kind(n) in KSet"call dotcall" && is_prefix_call(n)
+    if kind(n) == K"parameters"
+        is_call(n.parent) || return nothing
+        n.parent
     else
-        comp_keywords = !isempty(name) && startpos > separatorpos
-        complete_modules_only = false
+        # Check that we are beyond the function name.
+        is_call(n) && cur.index > children_nt(n)[1].index || return nothing
+        n
+    end
+end
+
+# If node is the field in a getfield-like expression, return the value
+# complete_symbol! should use as the prefix.
+function node_prefix(node::CursorNode, context_module::Module)
+    node.parent !== nothing || return nothing
+    p = node.parent
+    # In x.var"y", the parent is the "var" when the cursor is on "y".
+    kind(p) == K"var" && (p = p.parent)
+
+    # expr.node => expr
+    if kind(p) == K"."
+        n = children_nt(p)[1]
+        # Don't use prefix if we are the value
+        n !== node || return nothing
+        return Expr(n)
     end
 
-    complete_identifiers!(suggestions, context_module, string, name,
-                          pos, separatorpos, startpos;
-                          comp_keywords, complete_modules_only, shift)
-    return sort!(unique!(named_completion, suggestions), by=named_completion_completion), namepos:pos, true
+    if kind(p) == K"importpath"
+        if p.parent !== nothing && kind(p.parent) == K":" && p.index_nt > 1
+            # import A.B: C.node
+            chain = children_nt(children_nt(p.parent)[1])
+            append!(chain, children_nt(p)[1:end-1])
+        else
+            # import A.node
+            # import A.node: ...
+            chain = children_nt(p)[1:node.index_nt]
+            # Don't include the node under cursor in prefix unless it is `.`
+            kind(chain[end]) != K"." && deleteat!(chain, lastindex(chain))
+        end
+        length(chain) > 0 || return nothing
+
+        # (:importpath :x :y :z) => (:. (:. :x :y) :z)
+        # (:importpath :. :. :z) => (:. (parentmodule context_module) :z)
+        if (i = findlast(x -> kind(x) == K".", chain)) !== nothing
+            init = context_module
+            for j in 2:i
+                init = parentmodule(init)
+            end
+            deleteat!(chain, 1:i)
+        else
+            # No leading `.`, init is the first element of the path
+            init = chain[1].val
+            deleteat!(chain, 1)
+        end
+
+        # Convert the "chain" into nested (. a b) expressions.
+        all(x -> kind(x) == K"Identifier", chain) || return nothing
+        return foldl((x, y) -> Expr(:., x, Expr(:quote, y.val)), chain; init)
+    end
+
+    nothing
+end
+
+function dict_eval(@nospecialize(e), context_module::Module=Main)
+    objt = repl_eval_ex(e.args[1], context_module)
+    isa(objt, Core.Const) || return nothing
+    obj = objt.val
+    isa(obj, AbstractDict) || return nothing
+    (Base.haslength(obj) && length(obj)::Int < 1_000_000) || return nothing
+    return obj
 end
 
-function shell_completions(string, pos, hint::Bool=false)
+function method_search(partial::AbstractString, context_module::Module, shift::Bool)
+    rexm = match(r"(\w+\.|)\?\((.*)$", partial)
+    if rexm !== nothing
+        # Get the module scope
+        if isempty(rexm.captures[1])
+            callee_module = context_module
+        else
+            modname = Symbol(rexm.captures[1][1:end-1])
+            if isdefined(context_module, modname)
+                callee_module = getfield(context_module, modname)
+                if !isa(callee_module, Module)
+                    callee_module = context_module
+                end
+            else
+                callee_module = context_module
+            end
+        end
+        moreargs = !endswith(rexm.captures[2], ')')
+        callstr = "_(" * rexm.captures[2]
+        if moreargs
+            callstr *= ')'
+        end
+        ex_org = Meta.parse(callstr, raise=false, depwarn=false)
+        if isa(ex_org, Expr)
+            return complete_any_methods(ex_org, callee_module::Module, context_module, moreargs, shift), (0:length(rexm.captures[1])+1) .+ rexm.offset, false
+        end
+    end
+end
+
+function shell_completions(str, pos, hint::Bool=false; cmd_escape::Bool=false)
     # First parse everything up to the current position
-    scs = string[1:pos]
+    scs = str[1:pos]
     args, last_arg_start = try
         Base.shell_parse(scs, true)::Tuple{Expr,Int}
     catch ex
         ex isa ArgumentError || ex isa ErrorException || rethrow()
-        return Completion[], 0:-1, false
+        return Completion[], 1:0, false
     end
     ex = args.args[end]::Expr
     # Now look at the last thing we parsed
-    isempty(ex.args) && return Completion[], 0:-1, false
-    lastarg = ex.args[end]
+    isempty(ex.args) && return Completion[], 1:0, false
+    # Concatenate every string fragment so dir\file completes correctly.
+    lastarg = all(x -> x isa String, ex.args) ? string(ex.args...) : ex.args[end]
+
     # As Base.shell_parse throws away trailing spaces (unless they are escaped),
     # we need to special case here.
     # If the last char was a space, but shell_parse ignored it search on "".
     if isexpr(lastarg, :incomplete) || isexpr(lastarg, :error)
-        partial = string[last_arg_start:pos]
+        partial = str[last_arg_start:pos]
         ret, range = completions(partial, lastindex(partial), Main, true, hint)
         range = range .+ (last_arg_start - 1)
         return ret, range, true
     elseif endswith(scs, ' ') && !endswith(scs, "\\ ")
         r = pos+1:pos
-        paths, dir, success = complete_path("", use_envpath=false, shell_escape=true)
+        paths, dir, success = complete_path(""; use_envpath=false, shell_escape=!cmd_escape, cmd_escape, dirsep='/')
         return paths, r, success
     elseif all(@nospecialize(arg) -> arg isa AbstractString, ex.args)
         # Join these and treat this as a path
@@ -1550,44 +1336,63 @@ function shell_completions(string, pos, hint::Bool=false)
         # Also try looking into the env path if the user wants to complete the first argument
         use_envpath = length(args.args) < 2
 
-        expanded = complete_expanduser(path, r)
-        was_expanded = expanded[3]
-        if was_expanded
-            path = (only(expanded[1])::PathCompletion).path
-            # If tab press, ispath and user expansion available, return it now
-            # otherwise see if we can complete the path further before returning with expanded ~
-            !hint && ispath(path) && return expanded::Completions
-        end
+        paths, success = complete_path_string(path, hint; use_envpath, shell_escape=!cmd_escape, cmd_escape, dirsep='/')
+        return paths, r, success
+    end
+    return Completion[], 1:0, false
+end
 
-        paths, dir, success = complete_path(path, use_envpath=use_envpath, shell_escape=true, contract_user=was_expanded)
-
-        if success && !isempty(dir)
-            let dir = do_shell_escape(dir)
-                # if escaping of dir matches scs prefix, remove that from the completions
-                # otherwise make it the whole completion
-                partial = string[last_arg_start:pos]
-                if endswith(dir, "/") && startswith(partial, dir)
-                    r = (last_arg_start + sizeof(dir)):pos
-                elseif startswith(partial, dir * "/")
-                    r = nextind(string, last_arg_start + sizeof(dir)):pos
-                else
-                    map!(paths, paths) do c::PathCompletion
-                        return PathCompletion(dir * "/" * c.path)
-                    end
-                end
-            end
+function complete_path_string(path, hint::Bool=false;
+                              shell_escape::Bool=false,
+                              cmd_escape::Bool=false,
+                              string_escape::Bool=false,
+                              dirsep='/',
+                              kws...)
+    # Expand "~" and remember if we expanded it.
+    local expanded
+    try
+        let p = expanduser(path)
+            expanded = path != p
+            path = p
         end
-        # if ~ was expanded earlier and the incomplete string isn't a path
-        # return the path with contracted user to match what the hint shows. Otherwise expand ~
-        # i.e. require two tab presses to expand user
-        if was_expanded && !ispath(path)
-            map!(paths, paths) do c::PathCompletion
-                PathCompletion(contractuser(c.path))
-            end
+    catch e
+        e isa ArgumentError || rethrow()
+        expanded = false
+    end
+
+    function escape(p)
+        shell_escape && (p = do_shell_escape(p))
+        string_escape && (p = do_string_escape(p))
+        cmd_escape && (p = do_cmd_escape(p))
+        p
+    end
+
+    paths, dir, success = complete_path(path; dirsep, kws...)
+
+    # Expand '~' if the user hits TAB after exhausting completions (either
+    # because we have found an existing file, or there is no such file).
+    full_path = try
+        ispath(path) || isempty(paths)
+    catch err
+        # access(2) errors unhandled by ispath: EACCES, EIO, ELOOP, ENAMETOOLONG
+        if err isa Base.IOError
+            false
+        elseif err isa Base.ArgumentError && occursin("embedded NULs", err.msg)
+            false
+        else
+            rethrow()
         end
-        return paths, r, success
     end
-    return Completion[], 0:-1, false
+    expanded && !hint && full_path && return Completion[PathCompletion(escape(path))], true
+
+    # Expand '~' if the user hits TAB on a path ending in '/'.
+    expanded && (hint || path != dir * "/") && (dir = contractuser(dir))
+
+    map!(paths) do c::PathCompletion
+        p = joinpath_withsep(dir, c.path; dirsep)
+        PathCompletion(escape(p))
+    end
+    return sort!(paths, by=p->p.path), success
 end
 
 function __init__()
diff --git a/stdlib/REPL/src/SyntaxUtil.jl b/stdlib/REPL/src/SyntaxUtil.jl
new file mode 100644
index 0000000000000..6b455aa16dc9f
--- /dev/null
+++ b/stdlib/REPL/src/SyntaxUtil.jl
@@ -0,0 +1,111 @@
+module SyntaxUtil
+
+import Base.JuliaSyntax: build_tree
+using Base.JuliaSyntax:
+    AbstractSyntaxData, GreenNode, Kind, ParseStream, SourceFile, SyntaxHead, SyntaxNode, TreeNode,
+    byte_range, children, first_byte, head, is_leaf, is_trivia, kind, parse_julia_literal, span,
+    @K_str, _unsafe_wrap_substring
+
+export CursorNode, char_range, char_last, children_nt, find_delim, seek_pos
+
+# Like SyntaxNode, but keeps trivia, and tracks each child's index in its parent.
+# Extracted from JuliaSyntax/src/syntax_tree.jl
+# TODO: don't duplicate so much code?
+struct CursorData <: AbstractSyntaxData
+    source::SourceFile
+    raw::GreenNode{SyntaxHead}
+    position::Int
+    index::Int
+    index_nt::Int # nth non-trivia in parent
+    val::Any
+end
+
+const CursorNode = TreeNode{CursorData}
+
+function CursorNode(source::SourceFile, raw::GreenNode{SyntaxHead};
+                    position::Integer=1)
+    GC.@preserve source begin
+        raw_offset, txtbuf = _unsafe_wrap_substring(source.code)
+        offset = raw_offset - source.byte_offset
+        _to_CursorNode(source, txtbuf, offset, raw, convert(Int, position))
+    end
+end
+
+function _to_CursorNode(source::SourceFile, txtbuf::Vector{UInt8}, offset::Int,
+                        raw::GreenNode{SyntaxHead},
+                        position::Int, index::Int=-1, index_nt::Int=-1)
+    if is_leaf(raw)
+        valrange = position:position + span(raw) - 1
+        val = parse_julia_literal(txtbuf, head(raw), valrange .+ offset)
+        return CursorNode(nothing, nothing, CursorData(source, raw, position, index, index_nt, val))
+    else
+        cs = CursorNode[]
+        pos = position
+        i_nt = 1
+        for (i,rawchild) in enumerate(children(raw))
+            push!(cs, _to_CursorNode(source, txtbuf, offset, rawchild, pos, i, i_nt))
+            pos += Int(rawchild.span)
+            i_nt += !is_trivia(rawchild)
+        end
+        node = CursorNode(nothing, cs, CursorData(source, raw, position, index, index_nt, nothing))
+        for c in cs
+            c.parent = node
+        end
+        return node
+    end
+end
+
+function build_tree(::Type{CursorNode}, stream::ParseStream;
+                    filename=nothing, first_line=1, kws...)
+    green_tree = build_tree(GreenNode, stream; kws...)
+    source = SourceFile(stream, filename=filename, first_line=first_line)
+    CursorNode(source, green_tree, position=first_byte(stream))
+end
+
+Base.show(io::IO, node::CursorNode) = show(io, MIME("text/plain"), node.raw)
+Base.show(io::IO, mime::MIME{Symbol("text/plain")}, node::CursorNode) = show(io, mime, node.raw)
+
+function Base.Expr(node::CursorNode)
+    (; filename, first_line) = node.source
+    src = SourceFile(node.source[byte_range(node)]; filename, first_line)
+    Expr(SyntaxNode(src, node.raw))
+end
+
+char_range(node) = node.position:char_last(node)
+char_last(node) = thisind(node.source, node.position + span(node) - 1)
+
+children_nt(node) = [n for n in children(node) if !is_trivia(n)]
+
+function seek_pos(node, pos)
+    pos in byte_range(node) || return nothing
+    (cs = children(node)) === nothing && return node
+    for n in cs
+        c = seek_pos(n, pos)
+        c === nothing || return c
+    end
+    node
+end
+
+find_parent(node, k::Kind) = find_parent(node, n -> kind(n) == k)
+function find_parent(node, f::Function)
+    while node !== nothing && !f(node)
+        node = node.parent
+    end
+    node
+end
+
+# Return the character range between left_kind and right_kind in node.  The left
+# delimiter must be present, while the range will extend to the rest of the node
+# if the right delimiter is missing.
+function find_delim(node, left_kind, right_kind)
+    cs = children(node)
+    left = findfirst(c -> kind(c) == left_kind, cs)
+    left !== nothing || return nothing, nothing
+    right = findlast(c -> kind(c) == right_kind, cs)
+    closed = right !== nothing && right != left
+    right = closed ? thisind(node.source, cs[right].position - 1) : char_last(node)
+    left = nextind(node.source, char_last(cs[left]))
+    return left:right, closed
+end
+
+end
diff --git a/stdlib/REPL/test/replcompletions.jl b/stdlib/REPL/test/replcompletions.jl
index d9aa11cf609dd..442dff90cc039 100644
--- a/stdlib/REPL/test/replcompletions.jl
+++ b/stdlib/REPL/test/replcompletions.jl
@@ -158,6 +158,10 @@ let ex =
             export exported_symbol
             exported_symbol(::WeirdNames) = nothing
 
+            macro ignoremacro(e...)
+                nothing
+            end
+
         end # module CompletionFoo
         test_repl_comp_dict = CompletionFoo.test_dict
         test_repl_comp_customdict = CompletionFoo.test_customdict
@@ -180,9 +184,11 @@ end
 
 test_complete(s) = map_completion_text(@inferred(completions(s, lastindex(s))))
 test_scomplete(s) =  map_completion_text(@inferred(shell_completions(s, lastindex(s))))
+# | is reserved in test_complete_pos
+test_complete_pos(s) = map_completion_text(@inferred(completions(replace(s, '|' => ""), findfirst('|', s)-1)))
 test_complete_context(s, m=@__MODULE__; shift::Bool=true) =
     map_completion_text(@inferred(completions(s,lastindex(s), m, shift)))
-test_complete_foo(s) = test_complete_context(s, Main.CompletionFoo)
+test_complete_foo(s; shift::Bool=true) = test_complete_context(s, Main.CompletionFoo; shift)
 test_complete_noshift(s) = map_completion_text(@inferred(completions(s, lastindex(s), Main, false)))
 
 test_bslashcomplete(s) =  map_named_completion(@inferred(bslash_completions(s, lastindex(s)))[2])
@@ -290,10 +296,11 @@ let s = "Main.CompletionFoo.bar.no_val_available"
     @test length(c)==0
 end
 
-#cannot do dot completion on infix operator
-let s = "+."
-    c, r = test_complete(s)
-    @test length(c)==0
+#cannot do dot completion on infix operator (get default completions)
+let s1 = "", s2 = "+."
+    c1, r1 = test_complete(s1)
+    c2, r2 = test_complete(s2)
+    @test length(c1)==length(c2)
 end
 
 # To complete on a variable of a type, the type T of the variable
@@ -458,13 +465,13 @@ let
     c, r, res = test_complete(s)
     @test !res
     @test all(m -> string(m) in c, methods(isnothing))
-    @test s[r] == s[1:end-1]
+    @test s[r] == s[2:end-1]
 
     s = "!!isnothing("
     c, r, res = test_complete(s)
     @test !res
     @test all(m -> string(m) in c, methods(isnothing))
-    @test s[r] == s[1:end-1]
+    @test s[r] == s[3:end-1]
 end
 
 # Test completion of methods with input concrete args and args where typeinference determine their type
@@ -1052,7 +1059,7 @@ end
 let c, r, res
     c, r, res = test_scomplete("\$a")
     @test c == String[]
-    @test r === 0:-1
+    @test r === 1:0
     @test res === false
 end
 
@@ -1064,38 +1071,38 @@ let s, c, r
     # Issue #8047
     s = "@show \"/dev/nul"
     c,r = test_complete(s)
-    @test "null\"" in c
-    @test r == 13:15
-    @test s[r] == "nul"
+    @test "/dev/null\"" in c
+    @test r == 8:15
+    @test s[r] == "/dev/nul"
 
     # Tests path in Julia code and not closing " if it's a directory
     # Issue #8047
     s = "@show \"/tm"
     c,r = test_complete(s)
-    @test "tmp/" in c
-    @test r == 9:10
-    @test s[r] == "tm"
+    @test "/tmp/" in c
+    @test r == 8:10
+    @test s[r] == "/tm"
 
     # Tests path in Julia code and not double-closing "
     # Issue #8047
     s = "@show \"/dev/nul\""
     c,r = completions(s, 15)
     c = map(named_completion, c)
-    @test "null\"" in [_c.completion for _c in c]
-    @test r == 13:15
-    @test s[r] == "nul"
+    @test "/dev/null" in [_c.completion for _c in c]
+    @test r == 8:15
+    @test s[r] == "/dev/nul"
 
     s = "/t"
     c,r = test_scomplete(s)
-    @test "tmp/" in c
-    @test r == 2:2
-    @test s[r] == "t"
+    @test "/tmp/" in c
+    @test r == 1:2
+    @test s[r] == "/t"
 
     s = "/tmp"
     c,r = test_scomplete(s)
-    @test "tmp/" in c
-    @test r == 2:4
-    @test s[r] == "tmp"
+    @test "/tmp/" in c
+    @test r == 1:4
+    @test s[r] == "/tmp"
 
     # This should match things that are inside the tmp directory
     s = tempdir()
@@ -1106,7 +1113,7 @@ let s, c, r
         c,r = test_scomplete(s)
         @test !("tmp/" in c)
         @test !("$s/tmp/" in c)
-        @test r === (sizeof(s) + 1):sizeof(s)
+        @test r === 1:sizeof(s)
     end
 
     s = "cd \$(Iter"
@@ -1131,8 +1138,8 @@ let s, c, r
         touch(file)
         s = string(tempdir(), "/repl\\ ")
         c,r = test_scomplete(s)
-        @test ["'repl completions'"] == c
-        @test s[r] == "repl\\ "
+        @test [Base.shell_escape_posixly(joinpath(tempdir(),  "repl completions"))] == c
+        @test s[r] == string(tempdir(), "/repl\\ ")
         rm(file)
     end
 
@@ -1144,12 +1151,19 @@ let s, c, r
             mkdir(dir)
             s = "\"" * path * "/tmpfoob"
             c,r = test_complete(s)
-            @test "tmpfoobar/" in c
-            l = 3 + length(path)
-            @test r == l:l+6
-            @test s[r] == "tmpfoob"
+            @test string(dir, "/") in c
+            @test r == 2:sizeof(s)
+            @test s[r] == joinpath(path, "tmpfoob")
+
+            # Homedir expansion inside Cmd string (#57624)
+            s = "`ls " * path * "/tmpfoob"
+            c,r = test_complete(s)
+            @test string(dir, "/") in c
+            @test r == 5:sizeof(s)
+            @test s[r] == joinpath(path, "tmpfoob")
+
             s = "\"~"
-            @test "tmpfoobar/" in c
+            @test joinpath(path, "tmpfoobar/") in c
             c,r = test_complete(s)
             s = "\"~user"
             c, r = test_complete(s)
@@ -1248,7 +1262,7 @@ let current_dir, forbidden
                 e isa Base.IOError && occursin("ELOOP", e.msg)
             end
             c, r = test_complete("\"$(escape_string(path))/selfsym")
-            @test c == ["selfsymlink\""]
+            @test c == [escape_string(joinpath(path, "selfsymlink")) * "\""]
         end
     end
 
@@ -1285,47 +1299,47 @@ mktempdir() do path
         s = Sys.iswindows() ? "cd $dir_space\\\\space" : "cd $dir_space/space"
         c, r = test_scomplete(s)
         @test s[r] == (Sys.iswindows() ? "$dir_space\\\\space" : "$dir_space/space")
-        @test "'$space_folder'/'space .file'" in c
+        @test "'$space_folder/space .file'" in c
         # Also use shell escape rules within cmd backticks
         s = "`$s"
         c, r = test_scomplete(s)
         @test s[r] == (Sys.iswindows() ? "$dir_space\\\\space" : "$dir_space/space")
-        @test "'$space_folder'/'space .file'" in c
+        @test "'$space_folder/space .file'" in c
 
         # escape string according to Julia escaping rules
         julia_esc(str) = REPL.REPLCompletions.do_string_escape(str)
 
         # For normal strings the string should be properly escaped according to
         # the usual rules for Julia strings.
-        s = "cd(\"" * julia_esc(joinpath(path, space_folder) * "/space")
+        s = "cd(\"" * julia_esc(joinpath(path, space_folder, "space"))
         c, r = test_complete(s)
-        @test s[r] == "space"
-        @test "space .file\"" in c
+        @test s[r] == julia_esc(joinpath(path, space_folder, "space"))
+        @test julia_esc(joinpath(path, space_folder, "space .file")) * "\"" in c
 
         # '$' is the only character which can appear in a windows filename and
         # which needs to be escaped in Julia strings (on unix we could do this
         # test with all sorts of special chars)
         touch(joinpath(space_folder, "needs_escape\$.file"))
-        escpath = julia_esc(joinpath(path, space_folder) * "/needs_escape\$")
+        escpath = julia_esc(joinpath(path, space_folder, "needs_escape\$"))
         s = "cd(\"$escpath"
         c, r = test_complete(s)
-        @test s[r] == "needs_escape\\\$"
-        @test "needs_escape\\\$.file\"" in c
+        @test s[r] == julia_esc(joinpath(path, space_folder, "needs_escape\$"))
+        @test julia_esc(joinpath(path, space_folder, "needs_escape\$.file")) * "\"" in c
 
         if !Sys.iswindows()
             touch(joinpath(space_folder, "needs_escape2\n\".file"))
             escpath = julia_esc(joinpath(path, space_folder, "needs_escape2\n\""))
             s = "cd(\"$escpath"
             c, r = test_complete(s)
-            @test s[r] == "needs_escape2\\n\\\""
-            @test "needs_escape2\\n\\\".file\"" in c
+            @test s[r] == joinpath(path, space_folder, "needs_escape2\\n\\\"")
+            @test joinpath(path, space_folder, "needs_escape2\\n\\\".file\"") in c
 
             touch(joinpath(space_folder, "needs_escape3\\.file"))
             escpath = julia_esc(joinpath(path, space_folder, "needs_escape3\\"))
             s = "cd(\"$escpath"
             c, r = test_complete(s)
-            @test s[r] == "needs_escape3\\\\"
-            @test "needs_escape3\\\\.file\"" in c
+            @test s[r] == joinpath(path, space_folder, "needs_escape3\\\\")
+            @test joinpath(path, space_folder, "needs_escape3\\\\.file\"") in c
         end
 
         # Test for issue #10324
@@ -1339,16 +1353,17 @@ mktempdir() do path
             test_dir = "test$(c)test"
             mkdir(joinpath(path, test_dir))
             try
-                if !(c in ['\'','$']) # As these characters hold special meaning
+                # TODO: test on Windows when backslash-paths fixed
+                if !Sys.iswindows() && !(c in ['\'','$']) # As these characters hold special meaning
                     # in shell commands the shell path completion cannot complete
                     # paths with these characters
                     c, r, res = test_scomplete(test_dir)
-                    @test c[1] == "'$test_dir/'"
+                    @test c[1] == "'$(joinpath(test_dir, ""))'"
                     @test res
                 end
                 escdir = julia_esc(test_dir)
                 c, r, res = test_complete("\""*escdir)
-                @test c[1] == escdir * "/"
+                @test c[1] == julia_esc(joinpath(test_dir, ""))
                 @test res
             finally
                 rm(joinpath(path, test_dir), recursive=true)
@@ -1361,7 +1376,7 @@ end
 # Test tilde path completion
 let (c, r, res) = test_complete("\"~/ka8w5rsz")
     if !Sys.iswindows()
-        @test res && c == String[homedir() * "/ka8w5rsz"]
+        @test res && c == String[homedir() * "/ka8w5rsz\""]
     else
         @test !res
     end
@@ -1376,7 +1391,7 @@ if !Sys.iswindows()
     try
         let (c, r, res) = test_complete("\"~/Zx6Wa0GkC")
             @test res
-            @test c == String["Zx6Wa0GkC0/"]
+            @test c == String["~/Zx6Wa0GkC0/"]
         end
         let (c, r, res) = test_complete("\"~/Zx6Wa0GkC0")
             @test res
@@ -1384,11 +1399,11 @@ if !Sys.iswindows()
         end
         let (c, r, res) = test_complete("\"~/Zx6Wa0GkC0/my_")
             @test res
-            @test c == String["my_file\""]
+            @test c == String["~/Zx6Wa0GkC0/my_file\""]
         end
         let (c, r, res) = test_complete("\"~/Zx6Wa0GkC0/my_file")
             @test res
-            @test c == String[homedir() * "/Zx6Wa0GkC0/my_file"]
+            @test c == String[homedir() * "/Zx6Wa0GkC0/my_file\""]
         end
     finally
         rm(path, recursive=true)
@@ -1414,8 +1429,8 @@ if Sys.iswindows()
 
         s = "cd ../"
         c,r = test_scomplete(s)
-        @test r == lastindex(s)+1:lastindex(s)
-        @test "$temp_name/" in c
+        @test r == 4:6
+        @test "../$temp_name/" in c
 
         s = "ls $(file[1:2])"
         c,r = test_scomplete(s)
@@ -1425,12 +1440,12 @@ if Sys.iswindows()
         s = "cd(\"..\\\\"
         c,r = test_complete(s)
         @test r == lastindex(s)-3:lastindex(s)
-        @test "../$temp_name/" in c
+        @test "..\\\\$temp_name\\\\" in c
 
         s = "cd(\"../"
         c,r = test_complete(s)
-        @test r == lastindex(s)+1:lastindex(s)
-        @test "$temp_name/" in c
+        @test r == 5:7
+        @test "..\\\\$temp_name\\\\" in c
 
         s = "cd(\"$(file[1:2])"
         c,r = test_complete(s)
@@ -1485,10 +1500,10 @@ function test_dict_completion(dict_name)
     s = "$dict_name[ \"abcd"  # leading whitespace
     c, r = test_complete(s)
     @test c == Any["\"abcd\"]"]
-    s = "$dict_name[\"abcd]"  # trailing close bracket
+    s = "$dict_name[Bas]"  # trailing close bracket
     c, r = completions(s, lastindex(s) - 1)
     c = map(x -> named_completion(x).completion, c)
-    @test c == Any["\"abcd\""]
+    @test c == Any["Base"]
     s = "$dict_name[:b"
     c, r = test_complete(s)
     @test c == Any[":bar", ":bar2"]
@@ -1542,9 +1557,13 @@ test_dict_completion("test_repl_comp_customdict")
 
 @testset "dict_identifier_key" begin
     # Issue #23004: this should not throw:
-    @test REPLCompletions.dict_identifier_key("test_dict_ℂ[\\", :other) isa Tuple
+    let s = "test_dict_ℂ[\\"
+        @test REPLCompletions.completions(s, sizeof(s), Main.CompletionFoo) isa Tuple
+    end
     # Issue #55931: neither should this:
-    @test REPLCompletions.dict_identifier_key("test_dict_no_length[", :other) isa NTuple{3,Nothing}
+    let s = "test_dict_no_length["
+        @test REPLCompletions.completions(s, sizeof(s), Main.CompletionFoo) isa Tuple
+    end
 end
 
 @testset "completion of string/cmd macros (#22577)" begin
@@ -2485,8 +2504,139 @@ let (c, r, res) = test_complete_context("global xxx::Number = Base.", Main)
     @test "pi" ∈ c
 end
 
+# #55842
+let (c, r) = test_complete_pos("@tim| using Date")
+    @test "@time" in c
+    @test r == 1:4
+end
+
+# #56389
+let s = "begin\n  using Ran"
+    c, r = test_complete(s)
+    @test "Random" in c
+    @test r == 15:17
+    @test s[r] == "Ran"
+end
+let s = "using .CompletionFoo: bar, type_"
+    c, r = test_complete(s)
+    @test "type_test" in c
+    @test r == 28:32
+    @test s[r] == "type_"
+end
+
+# #55518
+let s = "CompletionFoo.@barfoo nothi"
+    c, r = test_complete(s)
+    @test "nothing" in c
+    @test r == 23:27
+end
+let s = "CompletionFoo.@barfoo kwtest"
+    c, r = test_complete(s)
+    @test isempty(c)
+end
+let s = "CompletionFoo.kwtest(x=type"
+    c, r = test_complete(s)
+    @test "typeof" in c
+    @test !("type_test" in c)
+    @test r == 24:27
+end
+let s = "CompletionFoo.bar; nothi"
+    c, r = test_complete(s)
+    @test "nothing" in c
+    @test r == 20:24
+end
+let s = "CompletionFoo.bar; @ti"
+    c, r = test_complete(s)
+    @test "@time" in c
+    @test r == 20:22
+end
+let s = "x = sin.([1]); y = ex"
+    c, r = test_complete(s)
+    @test "exp" in c
+    @test r == 20:21
+end
+
+# #57611
+let s = "x = Base.BinaryPlatforms.ar"
+    c, r = test_complete(s)
+    @test "arch" in c
+    @test r == 26:27
+end
+
+# #55520
+let s = "@ignoremacro A .= A setup=(A=ident"
+    c, r = test_complete(s)
+    @test "identity"in c
+    @test r == 30:34
+end
+
+# #57307
+let s = "unicode_αβγ.yy = named.len"
+    c, r = test_complete_foo(s)
+    @test "len2" in c
+    @test r == 27:29
+end
+
+# #55429
+let s = "@time @eval CompletionFoo.Compl"
+    c, r = test_complete(s)
+    @test "CompletionFoo2" in c
+    @test r == 27:31
+end
+
+# #55420
+let s = "CompletionFoo.test(iden"
+    c, r = test_complete(s)
+    @test "identity" in c
+    @test r == 20:23
+end
+
+# #57772
+let s = "sum(!ismis"
+    c, r = test_complete(s)
+    @test "ismissing" in c
+    @test r == 6:10
+end
+let s = "sum(!!ismis"
+    c, r = test_complete(s)
+    @test "ismissing" in c
+    @test r == 7:11
+end
+
+# Don't trigger complete_methods! when the cursor is on the function name.
+let s = "prin|(\"hello\")"
+    c, r = test_complete_pos(s)
+    @test "print" in c
+    @test r == 1:4
+end
+
+# Don't crash when tab-completing paths that cause ispath() to throw
+let s = "include(\"" * repeat("a", 5000) # ENAMETOOLONG
+    c, r = test_complete(s)
+    @test isempty(c)
+end
+
 # JuliaLang/julia#57780
 const issue57780 = ["a", "b", "c"]
 const issue57780_orig = copy(issue57780)
 test_complete_context("empty!(issue57780).", Main)
 @test issue57780 == issue57780_orig
+
+# Completion inside string interpolation
+let s = "\"example: \$varflo"
+    c, r = test_complete_foo(s)
+    @test "varfloat" in c
+    @test r == 12:17
+end
+
+let s = "\"example: \$(3 + findfir"
+    c, r = test_complete(s)
+    @test "findfirst" in c
+    @test r == 17:23
+end
+
+let s = "\"example: \$(named.len"
+    c, r = test_complete_foo(s)
+    @test "len2" in c
+    @test r == 19:21
+end

From 44f35d9991135071ade7e7a62bfae72300593af0 Mon Sep 17 00:00:00 2001
From: Timothy <git@tecosaur.net>
Date: Wed, 23 Apr 2025 01:25:55 +0800
Subject: [PATCH 37/38] Workaround StyledStrings type-piracy (#58112)

After discussion with Cody, this is an attempt at a more minimal version
of #56194.

The intent is to work around the invalidation issue introduced by the
split design with AnnotatedStrings, resolving the headache for 1.12.

Paired with https://github.com/JuliaLang/StyledStrings.jl/pull/115

Many thanks to @topolarity for working out this approach, the discussion
on balancing the short/long term fixes for this issue.

------

From my understanding of the problem, this should fix the
`write`/`print`/`show` invalidations, but this needs to be checked.

---------

Co-authored-by: Cody Tapscott <topolarity@tapscott.me>
(cherry picked from commit 6d78a4ae91078cea43470f8cd6d895e0c9b3d5e7)
---
 base/strings/annotated_io.jl                  | 75 +++++++++++++++++++
 .../md5                                       |  1 +
 .../sha512                                    |  1 +
 .../md5                                       |  1 -
 .../sha512                                    |  1 -
 stdlib/StyledStrings.version                  |  2 +-
 6 files changed, 78 insertions(+), 3 deletions(-)
 create mode 100644 deps/checksums/StyledStrings-3fe829fcf611b5fefaefb64df7e61f2ae82db117.tar.gz/md5
 create mode 100644 deps/checksums/StyledStrings-3fe829fcf611b5fefaefb64df7e61f2ae82db117.tar.gz/sha512
 delete mode 100644 deps/checksums/StyledStrings-8985a37ac054c37d084a03ad2837208244824877.tar.gz/md5
 delete mode 100644 deps/checksums/StyledStrings-8985a37ac054c37d084a03ad2837208244824877.tar.gz/sha512

diff --git a/base/strings/annotated_io.jl b/base/strings/annotated_io.jl
index 87db57b8030c9..9698fd5909b68 100644
--- a/base/strings/annotated_io.jl
+++ b/base/strings/annotated_io.jl
@@ -199,3 +199,78 @@ function _insert_annotations!(io::AnnotatedIOBuffer, annotations::Vector{RegionA
         push!(io.annotations, setindex(annotations[index], start+offset:stop+offset, :region))
     end
 end
+
+# NOTE: This is an interim solution to the invalidations caused
+# by the split styled display implementation. This should be
+# replaced by a more robust solution (such as a consolidation of
+# the type and method definitions) in the near future.
+module AnnotatedDisplay
+
+using ..Base: IO, SubString, AnnotatedString, AnnotatedChar, AnnotatedIOBuffer
+using ..Base: eachregion, invoke_in_world, tls_world_age
+
+# Write
+
+ansi_write(f::Function, io::IO, x::Any) = f(io, String(x))
+
+ansi_write_(f::Function, io::IO, @nospecialize(x::Any)) =
+    invoke_in_world(tls_world_age(), ansi_write, f, io, x)
+
+Base.write(io::IO, s::Union{<:AnnotatedString, SubString{<:AnnotatedString}}) =
+    ansi_write_(write, io, s)::Int
+
+Base.write(io::IO, c::AnnotatedChar) =
+    ansi_write_(write, io, c)::Int
+
+function Base.write(io::IO, aio::AnnotatedIOBuffer)
+    if get(io, :color, false) == true
+        # This does introduce an overhead that technically
+        # could be avoided, but I'm not sure that it's currently
+        # worth the effort to implement an efficient version of
+        # writing from a AnnotatedIOBuffer with style.
+        # In the meantime, by converting to an `AnnotatedString` we can just
+        # reuse all the work done to make that work.
+        ansi_write_(write, io, read(aio, AnnotatedString))::Int
+    else
+        write(io, aio.io)
+    end
+end
+
+# Print
+
+Base.print(io::IO, s::Union{<:AnnotatedString, SubString{<:AnnotatedString}}) =
+    (ansi_write_(write, io, s); nothing)
+
+Base.print(io::IO, s::AnnotatedChar) =
+    (ansi_write_(write, io, s); nothing)
+
+Base.print(io::AnnotatedIOBuffer, s::Union{<:AnnotatedString, SubString{<:AnnotatedString}}) =
+    (write(io, s); nothing)
+
+Base.print(io::AnnotatedIOBuffer, c::AnnotatedChar) =
+    (write(io, c); nothing)
+
+# Escape
+
+Base.escape_string(io::IO, s::Union{<:AnnotatedString, SubString{<:AnnotatedString}},
+              esc = ""; keep = (), ascii::Bool=false, fullhex::Bool=false) =
+    (ansi_write_((io, s) -> escape_string(io, s, esc; keep, ascii, fullhex), io, s); nothing)
+
+# Show
+
+show_annot(io::IO, ::Any) = nothing
+show_annot(io::IO, ::MIME, ::Any) = nothing
+
+show_annot_(io::IO, @nospecialize(x::Any)) =
+    invoke_in_world(tls_world_age(), show_annot, io, x)::Nothing
+
+show_annot_(io::IO, m::MIME, @nospecialize(x::Any)) =
+    invoke_in_world(tls_world_age(), show_annot, io, m, x)::Nothing
+
+Base.show(io::IO, m::MIME"text/html", s::Union{<:AnnotatedString, SubString{<:AnnotatedString}}) =
+    show_annot_(io, m, s)
+
+Base.show(io::IO, m::MIME"text/html", c::AnnotatedChar) =
+    show_annot_(io, m, c)
+
+end
diff --git a/deps/checksums/StyledStrings-3fe829fcf611b5fefaefb64df7e61f2ae82db117.tar.gz/md5 b/deps/checksums/StyledStrings-3fe829fcf611b5fefaefb64df7e61f2ae82db117.tar.gz/md5
new file mode 100644
index 0000000000000..46d5cacf788df
--- /dev/null
+++ b/deps/checksums/StyledStrings-3fe829fcf611b5fefaefb64df7e61f2ae82db117.tar.gz/md5
@@ -0,0 +1 @@
+1cb6007a66d3f74cbe5b27ee449aa9c8
diff --git a/deps/checksums/StyledStrings-3fe829fcf611b5fefaefb64df7e61f2ae82db117.tar.gz/sha512 b/deps/checksums/StyledStrings-3fe829fcf611b5fefaefb64df7e61f2ae82db117.tar.gz/sha512
new file mode 100644
index 0000000000000..724b2d311c123
--- /dev/null
+++ b/deps/checksums/StyledStrings-3fe829fcf611b5fefaefb64df7e61f2ae82db117.tar.gz/sha512
@@ -0,0 +1 @@
+1fa95646fdf4cc7ea282bd355fded9464e7572792912942ea1c45f6ed126eead2333fdeed92e7db3efbcd6c3a171a04e5c9562dab2685bb39947136284ae1da3
diff --git a/deps/checksums/StyledStrings-8985a37ac054c37d084a03ad2837208244824877.tar.gz/md5 b/deps/checksums/StyledStrings-8985a37ac054c37d084a03ad2837208244824877.tar.gz/md5
deleted file mode 100644
index 0fd8e8966e068..0000000000000
--- a/deps/checksums/StyledStrings-8985a37ac054c37d084a03ad2837208244824877.tar.gz/md5
+++ /dev/null
@@ -1 +0,0 @@
-411277f3701cc3e286ec8a84ccdf6f11
diff --git a/deps/checksums/StyledStrings-8985a37ac054c37d084a03ad2837208244824877.tar.gz/sha512 b/deps/checksums/StyledStrings-8985a37ac054c37d084a03ad2837208244824877.tar.gz/sha512
deleted file mode 100644
index 0b495aefef55d..0000000000000
--- a/deps/checksums/StyledStrings-8985a37ac054c37d084a03ad2837208244824877.tar.gz/sha512
+++ /dev/null
@@ -1 +0,0 @@
-95a7e92389f6fd02d3bec17ec0201ba41316aa2d7c321b14af88ccce8246fd0000ed2c0cc818f87cb81f7134304233db897f656426a00caac1bc7635056260c2
diff --git a/stdlib/StyledStrings.version b/stdlib/StyledStrings.version
index c72f7a8399725..55a4a08c17ea0 100644
--- a/stdlib/StyledStrings.version
+++ b/stdlib/StyledStrings.version
@@ -1,4 +1,4 @@
 STYLEDSTRINGS_BRANCH = main
-STYLEDSTRINGS_SHA1 = 8985a37ac054c37d084a03ad2837208244824877
+STYLEDSTRINGS_SHA1 = 3fe829fcf611b5fefaefb64df7e61f2ae82db117
 STYLEDSTRINGS_GIT_URL := https://github.com/JuliaLang/StyledStrings.jl.git
 STYLEDSTRINGS_TAR_URL = https://api.github.com/repos/JuliaLang/StyledStrings.jl/tarball/$1

From debca00c9017cfd5ae27ebf3c74978e6fbfc4c5f Mon Sep 17 00:00:00 2001
From: Shuhei Kadowaki <aviatesk@gmail.com>
Date: Wed, 8 Jan 2025 13:33:52 +0900
Subject: [PATCH 38/38] staticdata: remove `reinit_ccallable`

This commit removes `jl_reinit_ccallable` whose purpose is unclear.
Specifically, the function re-adds C-callable functions to the execution
engine during the loading of sysimages/pkgimages, but the consensus is
that the function is largely unnecessary because `ccall` can find
symbols via `dlsym`. The function's only apparent use case is a
contrived `llvmcall` example, only because we currently don't add the
sysimage symbols to the JIT, but we could do anyway. `llvmcall` has
always been experimental, and if it is truly needed, the functionality
for finding the symbols should be properly implemented later.
---
 src/aotcompile.cpp        |   2 +-
 src/codegen-stubs.c       |   1 -
 src/gf.c                  |  38 +++++++++++
 src/jitlayers.cpp         | 135 --------------------------------------
 src/jitlayers.h           |   2 +
 src/jl_exported_funcs.inc |   2 -
 src/julia_internal.h      |   1 -
 src/staticdata.c          |  51 +-------------
 test/llvmcall.jl          |  54 ---------------
 test/precompile.jl        |  33 ++++------
 10 files changed, 56 insertions(+), 263 deletions(-)

diff --git a/src/aotcompile.cpp b/src/aotcompile.cpp
index b1d925d89c7ce..275a8004be2b9 100644
--- a/src/aotcompile.cpp
+++ b/src/aotcompile.cpp
@@ -800,7 +800,7 @@ void *jl_emit_native_impl(jl_array_t *codeinfos, LLVMOrcThreadSafeModuleRef llvm
         else {
             jl_value_t *sig = jl_array_ptr_ref(codeinfos, ++i);
             assert(jl_is_type(item) && jl_is_type(sig));
-            jl_compile_extern_c(wrap(&clone), &params, NULL, item, sig);
+            jl_generate_ccallable(clone.getModuleUnlocked(), nullptr, item, sig, params);
         }
     }
     // finally, make sure all referenced methods get fixed up, particularly if the user declined to compile them
diff --git a/src/codegen-stubs.c b/src/codegen-stubs.c
index 6b547251eaab8..707811089489b 100644
--- a/src/codegen-stubs.c
+++ b/src/codegen-stubs.c
@@ -17,7 +17,6 @@ JL_DLLEXPORT void jl_get_llvm_gvs_fallback(void *native_code, arraylist_t *gvs)
 JL_DLLEXPORT void jl_get_llvm_external_fns_fallback(void *native_code, arraylist_t *gvs) UNAVAILABLE
 JL_DLLEXPORT void jl_get_llvm_mis_fallback(void *native_code, arraylist_t* MIs) UNAVAILABLE
 
-JL_DLLEXPORT void jl_extern_c_fallback(jl_function_t *f, jl_value_t *rt, jl_value_t *argt, char *name) UNAVAILABLE
 JL_DLLEXPORT jl_value_t *jl_dump_method_asm_fallback(jl_method_instance_t *linfo, size_t world,
         char emit_mc, char getwrapper, const char* asm_variant, const char *debuginfo, char binary) UNAVAILABLE
 JL_DLLEXPORT jl_value_t *jl_dump_function_ir_fallback(jl_llvmf_dump_t *dump, char strip_ir_metadata, char dump_module, const char *debuginfo) UNAVAILABLE
diff --git a/src/gf.c b/src/gf.c
index 69bcd916cb7e2..8c8882ea8cf5e 100644
--- a/src/gf.c
+++ b/src/gf.c
@@ -4643,6 +4643,44 @@ JL_DLLEXPORT void jl_typeinf_timing_end(uint64_t start, int is_recompile)
     }
 }
 
+// declare a C-callable entry point; called during code loading from the toplevel
+JL_DLLEXPORT void jl_extern_c(jl_value_t *declrt, jl_tupletype_t *sigt)
+{
+    // validate arguments. try to do as many checks as possible here to avoid
+    // throwing errors later during codegen.
+    JL_TYPECHK(@ccallable, type, declrt);
+    if (!jl_is_tuple_type(sigt))
+        jl_type_error("@ccallable", (jl_value_t*)jl_anytuple_type_type, (jl_value_t*)sigt);
+    // check that f is a guaranteed singleton type
+    jl_datatype_t *ft = (jl_datatype_t*)jl_tparam0(sigt);
+    if (!jl_is_datatype(ft) || !jl_is_datatype_singleton(ft))
+        jl_error("@ccallable: function object must be a singleton");
+
+    // compute / validate return type
+    if (!jl_is_concrete_type(declrt) || jl_is_kind(declrt))
+        jl_error("@ccallable: return type must be concrete and correspond to a C type");
+    if (!jl_type_mappable_to_c(declrt))
+        jl_error("@ccallable: return type doesn't correspond to a C type");
+
+    // validate method signature
+    size_t i, nargs = jl_nparams(sigt);
+    for (i = 1; i < nargs; i++) {
+        jl_value_t *ati = jl_tparam(sigt, i);
+        if (!jl_is_concrete_type(ati) || jl_is_kind(ati) || !jl_type_mappable_to_c(ati))
+            jl_error("@ccallable: argument types must be concrete");
+    }
+
+    // save a record of this so that the alias is generated when we write an object file
+    jl_method_t *meth = (jl_method_t*)jl_methtable_lookup(ft->name->mt, (jl_value_t*)sigt, jl_atomic_load_acquire(&jl_world_counter));
+    if (!jl_is_method(meth))
+        jl_error("@ccallable: could not find requested method");
+    JL_GC_PUSH1(&meth);
+    meth->ccallable = jl_svec2(declrt, (jl_value_t*)sigt);
+    jl_gc_wb(meth, meth->ccallable);
+    JL_GC_POP();
+}
+
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/src/jitlayers.cpp b/src/jitlayers.cpp
index b8781d2bfe898..9b32464b3e11d 100644
--- a/src/jitlayers.cpp
+++ b/src/jitlayers.cpp
@@ -804,141 +804,6 @@ void jl_emit_codeinst_to_jit_impl(
     emittedmodules[codeinst] = std::move(result_m);
 }
 
-
-const char *jl_generate_ccallable(Module *llvmmod, void *sysimg_handle, jl_value_t *declrt, jl_value_t *sigt, jl_codegen_params_t &params);
-
-// compile a C-callable alias
-extern "C" JL_DLLEXPORT_CODEGEN
-int jl_compile_extern_c_impl(LLVMOrcThreadSafeModuleRef llvmmod, void *p, void *sysimg, jl_value_t *declrt, jl_value_t *sigt)
-{
-    auto ct = jl_current_task;
-    bool timed = (ct->reentrant_timing & 1) == 0;
-    if (timed)
-        ct->reentrant_timing |= 1;
-    uint64_t compiler_start_time = 0;
-    uint8_t measure_compile_time_enabled = jl_atomic_load_relaxed(&jl_measure_compile_time_enabled);
-    if (measure_compile_time_enabled)
-        compiler_start_time = jl_hrtime();
-    jl_codegen_params_t *pparams = (jl_codegen_params_t*)p;
-    DataLayout DL = pparams ? pparams->DL : jl_ExecutionEngine->getDataLayout();
-    Triple TargetTriple = pparams ? pparams->TargetTriple : jl_ExecutionEngine->getTargetTriple();
-    orc::ThreadSafeContext ctx;
-    auto into = unwrap(llvmmod);
-    orc::ThreadSafeModule backing;
-    bool success = true;
-    const char *name = "";
-    if (into == NULL) {
-        ctx = pparams ? pparams->tsctx : jl_ExecutionEngine->makeContext();
-        backing = jl_create_ts_module("cextern", ctx, DL, TargetTriple);
-        into = &backing;
-    }
-    { // params scope
-        jl_codegen_params_t params(into->getContext(), DL, TargetTriple);
-        if (pparams == NULL) {
-            params.cache = p == NULL;
-            params.imaging_mode = 0;
-            params.tsctx.getContext()->setDiscardValueNames(true);
-            pparams = &params;
-        }
-        Module &M = *into->getModuleUnlocked();
-        assert(pparams->tsctx.getContext() == &M.getContext());
-        name = jl_generate_ccallable(&M, sysimg, declrt, sigt, *pparams);
-        if (!sysimg && !p) {
-            { // drop lock to keep analyzer happy (since it doesn't know we have the only reference to it)
-                auto release = std::move(params.tsctx_lock);
-            }
-            { // lock scope
-                jl_unique_gcsafe_lock lock(extern_c_lock);
-                if (jl_ExecutionEngine->getGlobalValueAddress(name))
-                    success = false;
-            }
-            params.tsctx_lock = params.tsctx.getLock(); // re-acquire lock
-            if (success && params.cache) {
-                size_t newest_world = jl_atomic_load_acquire(&jl_world_counter);
-                for (auto &it : params.workqueue) { // really just zero or one, and just the ABI not the rest of the metadata
-                    jl_code_instance_t *codeinst = it.first;
-                    JL_GC_PROMISE_ROOTED(codeinst);
-                    jl_code_instance_t *newest_ci = jl_type_infer(jl_get_ci_mi(codeinst), newest_world, SOURCE_MODE_ABI);
-                    if (newest_ci) {
-                        if (jl_egal(codeinst->rettype, newest_ci->rettype))
-                            it.first = codeinst;
-                        jl_compile_codeinst_now(newest_ci);
-                    }
-                }
-                jl_analyze_workqueue(nullptr, params, true);
-                assert(params.workqueue.empty());
-                finish_params(&M, params, sharedmodules);
-            }
-        }
-        pparams = nullptr;
-    }
-    if (!sysimg && success && llvmmod == NULL) {
-        { // lock scope
-            jl_unique_gcsafe_lock lock(extern_c_lock);
-            if (!jl_ExecutionEngine->getGlobalValueAddress(name)) {
-                {
-                    auto Lock = backing.getContext().getLock();
-                    jl_ExecutionEngine->optimizeDLSyms(*backing.getModuleUnlocked()); // safepoint
-                }
-                jl_ExecutionEngine->addModule(std::move(backing));
-                success = jl_ExecutionEngine->getGlobalValueAddress(name);
-                assert(success);
-            }
-        }
-    }
-    if (timed) {
-        if (measure_compile_time_enabled) {
-            auto end = jl_hrtime();
-            jl_atomic_fetch_add_relaxed(&jl_cumulative_compile_time, end - compiler_start_time);
-        }
-        ct->reentrant_timing &= ~1ull;
-    }
-    return success;
-}
-
-// declare a C-callable entry point; called during code loading from the toplevel
-extern "C" JL_DLLEXPORT_CODEGEN
-void jl_extern_c_impl(jl_value_t *declrt, jl_tupletype_t *sigt)
-{
-    // validate arguments. try to do as many checks as possible here to avoid
-    // throwing errors later during codegen.
-    JL_TYPECHK(@ccallable, type, declrt);
-    if (!jl_is_tuple_type(sigt))
-        jl_type_error("@ccallable", (jl_value_t*)jl_anytuple_type_type, (jl_value_t*)sigt);
-    // check that f is a guaranteed singleton type
-    jl_datatype_t *ft = (jl_datatype_t*)jl_tparam0(sigt);
-    if (!jl_is_datatype(ft) || !jl_is_datatype_singleton(ft))
-        jl_error("@ccallable: function object must be a singleton");
-
-    // compute / validate return type
-    if (!jl_is_concrete_type(declrt) || jl_is_kind(declrt))
-        jl_error("@ccallable: return type must be concrete and correspond to a C type");
-    if (!jl_type_mappable_to_c(declrt))
-        jl_error("@ccallable: return type doesn't correspond to a C type");
-
-    // validate method signature
-    size_t i, nargs = jl_nparams(sigt);
-    for (i = 1; i < nargs; i++) {
-        jl_value_t *ati = jl_tparam(sigt, i);
-        if (!jl_is_concrete_type(ati) || jl_is_kind(ati) || !jl_type_mappable_to_c(ati))
-            jl_error("@ccallable: argument types must be concrete");
-    }
-
-    // save a record of this so that the alias is generated when we write an object file
-    jl_method_t *meth = (jl_method_t*)jl_methtable_lookup(ft->name->mt, (jl_value_t*)sigt, jl_atomic_load_acquire(&jl_world_counter));
-    if (!jl_is_method(meth))
-        jl_error("@ccallable: could not find requested method");
-    JL_GC_PUSH1(&meth);
-    meth->ccallable = jl_svec2(declrt, (jl_value_t*)sigt);
-    jl_gc_wb(meth, meth->ccallable);
-    JL_GC_POP();
-
-    // create the alias in the current runtime environment
-    int success = jl_compile_extern_c(NULL, NULL, NULL, declrt, (jl_value_t*)sigt);
-    if (!success)
-        jl_error("@ccallable was already defined for this method name");
-}
-
 extern "C" JL_DLLEXPORT_CODEGEN
 int jl_compile_codeinst_impl(jl_code_instance_t *ci)
 {
diff --git a/src/jitlayers.h b/src/jitlayers.h
index c1699a5c1d913..50e82b7849b80 100644
--- a/src/jitlayers.h
+++ b/src/jitlayers.h
@@ -284,6 +284,8 @@ struct jl_codegen_params_t {
     ~jl_codegen_params_t() JL_NOTSAFEPOINT JL_NOTSAFEPOINT_LEAVE = default;
 };
 
+const char *jl_generate_ccallable(Module *llvmmod, void *sysimg_handle, jl_value_t *declrt, jl_value_t *sigt, jl_codegen_params_t &params);
+
 jl_llvm_functions_t jl_emit_code(
         orc::ThreadSafeModule &M,
         jl_method_instance_t *mi,
diff --git a/src/jl_exported_funcs.inc b/src/jl_exported_funcs.inc
index dfa4cf8ffe62c..6d4077a60111b 100644
--- a/src/jl_exported_funcs.inc
+++ b/src/jl_exported_funcs.inc
@@ -511,7 +511,6 @@
     YY(jl_dump_function_ir) \
     YY(jl_dump_method_asm) \
     YY(jl_emit_codeinst_to_jit) \
-    YY(jl_extern_c) \
     YY(jl_get_llvmf_defn) \
     YY(jl_get_llvm_function) \
     YY(jl_get_llvm_module) \
@@ -528,7 +527,6 @@
     YY(jl_register_fptrs) \
     YY(jl_generate_fptr_for_unspecialized) \
     YY(jl_compile_codeinst) \
-    YY(jl_compile_extern_c) \
     YY(jl_teardown_codegen) \
     YY(jl_jit_total_bytes) \
     YY(jl_create_native) \
diff --git a/src/julia_internal.h b/src/julia_internal.h
index 3e93df73bccfe..72534aadafbb3 100644
--- a/src/julia_internal.h
+++ b/src/julia_internal.h
@@ -2027,7 +2027,6 @@ JL_DLLEXPORT uint32_t jl_crc32c(uint32_t crc, const char *buf, size_t len);
 
 JL_DLLIMPORT void jl_generate_fptr_for_unspecialized(jl_code_instance_t *unspec);
 JL_DLLIMPORT int jl_compile_codeinst(jl_code_instance_t *unspec);
-JL_DLLIMPORT int jl_compile_extern_c(LLVMOrcThreadSafeModuleRef llvmmod, void *params, void *sysimg, jl_value_t *declrt, jl_value_t *sigt);
 JL_DLLIMPORT void jl_emit_codeinst_to_jit(jl_code_instance_t *codeinst, jl_code_info_t *src);
 
 typedef struct {
diff --git a/src/staticdata.c b/src/staticdata.c
index d8420c2d81f3b..f24352bc4498f 100644
--- a/src/staticdata.c
+++ b/src/staticdata.c
@@ -44,8 +44,6 @@
 
   - step 3 combines the different sections (fields of `jl_serializer_state`) into one
 
-  - step 4 writes the values of the hard-coded tagged items and `ccallable_list`
-
 Much of the "real work" during deserialization is done by `get_item_for_reloc`. But a few items require specific
 attention:
 - uniquing: during deserialization, the target item (an "external" type or MethodInstance) must be checked against
@@ -556,7 +554,6 @@ typedef struct {
     arraylist_t uniquing_objs;  // a list of locations that reference non-types that must be de-duplicated
     arraylist_t fixup_types;    // a list of locations of types requiring (re)caching
     arraylist_t fixup_objs;     // a list of locations of objects requiring (re)caching
-    arraylist_t ccallable_list; // @ccallable entry points to install
     // mapping from a buildid_idx to a depmods_idx
     jl_array_t *buildid_depmods_idxs;
     // record of build_ids for all external linkages, in order of serialization for the current sysimg/pkgimg
@@ -1875,8 +1872,6 @@ static void jl_write_values(jl_serializer_state *s) JL_GC_DISABLED
                 else {
                     newm->nroots_sysimg = m->roots ? jl_array_len(m->roots) : 0;
                 }
-                if (m->ccallable)
-                    arraylist_push(&s->ccallable_list, (void*)reloc_offset);
             }
             else if (jl_is_method_instance(v)) {
                 assert(f == s->s);
@@ -2557,29 +2552,6 @@ static void jl_root_new_gvars(jl_serializer_state *s, jl_image_t *image, uint32_
     }
 }
 
-
-static void jl_compile_extern(jl_method_t *m, void *sysimg_handle) JL_GC_DISABLED
-{
-    // install ccallable entry point in JIT
-    assert(m); // makes clang-sa happy
-    jl_svec_t *sv = m->ccallable;
-    int success = jl_compile_extern_c(NULL, NULL, sysimg_handle, jl_svecref(sv, 0), jl_svecref(sv, 1));
-    if (!success)
-        jl_safe_printf("WARNING: @ccallable was already defined for this method name\n"); // enjoy a very bad time
-    assert(success || !sysimg_handle);
-}
-
-
-static void jl_reinit_ccallable(arraylist_t *ccallable_list, char *base, void *sysimg_handle)
-{
-    for (size_t i = 0; i < ccallable_list->len; i++) {
-        uintptr_t item = (uintptr_t)ccallable_list->items[i];
-        jl_method_t *m = (jl_method_t*)(base + item);
-        jl_compile_extern(m, sysimg_handle);
-    }
-}
-
-
 // Code below helps slim down the images by
 // removing cached types not referenced in the stream
 static jl_svec_t *jl_prune_type_cache_hash(jl_svec_t *cache) JL_GC_DISABLED
@@ -3106,7 +3078,6 @@ static void jl_save_system_image_to_stream(ios_t *f, jl_array_t *mod_array,
     arraylist_new(&s.uniquing_objs, 0);
     arraylist_new(&s.fixup_types, 0);
     arraylist_new(&s.fixup_objs, 0);
-    arraylist_new(&s.ccallable_list, 0);
     s.buildid_depmods_idxs = image_to_depmodidx(mod_array);
     s.link_ids_relocs = jl_alloc_array_1d(jl_array_int32_type, 0);
     s.link_ids_gctags = jl_alloc_array_1d(jl_array_int32_type, 0);
@@ -3363,7 +3334,6 @@ static void jl_save_system_image_to_stream(ios_t *f, jl_array_t *mod_array,
         write_uint32(f, jl_array_len(s.link_ids_external_fnvars));
         ios_write(f, (char*)jl_array_data(s.link_ids_external_fnvars, uint32_t), jl_array_len(s.link_ids_external_fnvars) * sizeof(uint32_t));
         write_uint32(f, external_fns_begin);
-        jl_write_arraylist(s.s, &s.ccallable_list);
     }
 
     assert(object_worklist.len == 0);
@@ -3375,7 +3345,6 @@ static void jl_save_system_image_to_stream(ios_t *f, jl_array_t *mod_array,
     arraylist_free(&s.uniquing_objs);
     arraylist_free(&s.fixup_types);
     arraylist_free(&s.fixup_objs);
-    arraylist_free(&s.ccallable_list);
     arraylist_free(&s.memowner_list);
     arraylist_free(&s.memref_list);
     arraylist_free(&s.relocs_list);
@@ -3677,7 +3646,7 @@ static void jl_restore_system_image_from_stream_(ios_t *f, jl_image_t *image, jl
                                                  jl_array_t **extext_methods, jl_array_t **internal_methods,
                                                  jl_array_t **new_ext_cis, jl_array_t **method_roots_list,
                                                  jl_array_t **edges,
-                                                 char **base, arraylist_t *ccallable_list, pkgcachesizes *cachesizes) JL_GC_DISABLED
+                                                 pkgcachesizes *cachesizes) JL_GC_DISABLED
 {
     jl_task_t *ct = jl_current_task;
     int en = jl_gc_enable(0);
@@ -3804,7 +3773,6 @@ static void jl_restore_system_image_from_stream_(ios_t *f, jl_image_t *image, jl
         ios_read(f, (char*)jl_array_data(s.link_ids_external_fnvars, uint32_t), nlinks_external_fnvars * sizeof(uint32_t));
     }
     uint32_t external_fns_begin = read_uint32(f);
-    jl_read_arraylist(s.s, ccallable_list ? ccallable_list : &s.ccallable_list);
     if (s.incremental) {
         assert(restored && init_order && extext_methods && internal_methods && new_ext_cis && method_roots_list && edges);
         *restored = (jl_array_t*)jl_delayed_reloc(&s, offset_restored);
@@ -3824,8 +3792,6 @@ static void jl_restore_system_image_from_stream_(ios_t *f, jl_image_t *image, jl
 
     char *image_base = (char*)&sysimg.buf[0];
     reloc_t *relocs_base = (reloc_t*)&relocs.buf[0];
-    if (base)
-        *base = image_base;
 
     s.s = &sysimg;
     jl_read_reloclist(&s, s.link_ids_gctags, GC_OLD | GC_IN_IMAGE); // gctags
@@ -4185,11 +4151,6 @@ static void jl_restore_system_image_from_stream_(ios_t *f, jl_image_t *image, jl
 
     s.s = &sysimg;
     jl_update_all_fptrs(&s, image); // fptr relocs and registration
-    if (!ccallable_list) {
-        // TODO: jl_sysimg_handle or img_handle?
-        jl_reinit_ccallable(&s.ccallable_list, image_base, jl_sysimg_handle);
-        arraylist_free(&s.ccallable_list);
-    }
     s.s = NULL;
 
     ios_close(&fptr_record);
@@ -4267,8 +4228,6 @@ static jl_value_t *jl_restore_package_image_from_stream(void* pkgimage_handle, i
 
     assert(datastartpos > 0 && datastartpos < dataendpos);
     needs_permalloc = jl_options.permalloc_pkgimg || needs_permalloc;
-    char *base;
-    arraylist_t ccallable_list;
 
     jl_value_t *restored = NULL;
     jl_array_t *init_order = NULL, *extext_methods = NULL, *internal_methods = NULL, *new_ext_cis = NULL, *method_roots_list = NULL, *edges = NULL;
@@ -4298,7 +4257,7 @@ static jl_value_t *jl_restore_package_image_from_stream(void* pkgimage_handle, i
             ios_static_buffer(f, sysimg, len);
             pkgcachesizes cachesizes;
             jl_restore_system_image_from_stream_(f, image, depmods, checksum, (jl_array_t**)&restored, &init_order, &extext_methods, &internal_methods, &new_ext_cis, &method_roots_list,
-                                                 &edges, &base, &ccallable_list, &cachesizes);
+                                                 &edges, &cachesizes);
             JL_SIGATOMIC_END();
 
             // Add roots to methods
@@ -4328,10 +4287,6 @@ static jl_value_t *jl_restore_package_image_from_stream(void* pkgimage_handle, i
             // now permit more methods to be added again
             JL_UNLOCK(&world_counter_lock);
 
-            // reinit ccallables
-            jl_reinit_ccallable(&ccallable_list, base, pkgimage_handle);
-            arraylist_free(&ccallable_list);
-
             jl_value_t *ext_edges = new_ext_cis ? (jl_value_t*)new_ext_cis : jl_nothing;
 
             if (completeinfo) {
@@ -4359,7 +4314,7 @@ static jl_value_t *jl_restore_package_image_from_stream(void* pkgimage_handle, i
 static void jl_restore_system_image_from_stream(ios_t *f, jl_image_t *image, uint32_t checksum)
 {
     JL_TIMING(LOAD_IMAGE, LOAD_Sysimg);
-    jl_restore_system_image_from_stream_(f, image, NULL, checksum | ((uint64_t)0xfdfcfbfa << 32), NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
+    jl_restore_system_image_from_stream_(f, image, NULL, checksum | ((uint64_t)0xfdfcfbfa << 32), NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
 }
 
 JL_DLLEXPORT jl_value_t *jl_restore_incremental_from_buf(void* pkgimage_handle, const char *buf, jl_image_t *image, size_t sz, jl_array_t *depmods, int completeinfo, const char *pkgname, int needs_permalloc)
diff --git a/test/llvmcall.jl b/test/llvmcall.jl
index ddf66ca680d45..9fd0505e24319 100644
--- a/test/llvmcall.jl
+++ b/test/llvmcall.jl
@@ -143,40 +143,6 @@ function call_jl_errno()
 end
 call_jl_errno()
 
-module ObjLoadTest
-    using Base: llvmcall, @ccallable
-    using Test
-    didcall = false
-    """    jl_the_callback()
-
-    Sets the global didcall when it did the call
-    """
-    @ccallable Cvoid function jl_the_callback()
-        global didcall
-        didcall = true
-        nothing
-    end
-    @test_throws(ErrorException("@ccallable was already defined for this method name"),
-            @eval @ccallable String jl_the_callback(not_the_method::Int) = "other")
-    # Make sure everything up until here gets compiled
-    @test jl_the_callback() === nothing
-    @test jl_the_callback(1) == "other"
-    didcall = false
-    function do_the_call()
-        llvmcall(
-            ("""declare void @jl_the_callback()
-                define void @entry() #0 {
-                0:
-                    call void @jl_the_callback()
-                    ret void
-                }
-                attributes #0 = { alwaysinline }
-            """, "entry"),Cvoid,Tuple{})
-    end
-    do_the_call()
-    @test didcall
-end
-
 # Test for proper parenting
 local foo
 function foo()
@@ -189,26 +155,6 @@ function foo()
 end
 code_llvm(devnull, foo, ())
 
-module CcallableRetTypeTest
-    using Base: llvmcall, @ccallable
-    using Test
-    @ccallable function jl_test_returns_float()::Float64
-        return 42
-    end
-    function do_the_call()
-        llvmcall(
-            ("""declare double @jl_test_returns_float()
-                define double @entry() #0 {
-                0:
-                    %1 = call double @jl_test_returns_float()
-                    ret double %1
-                }
-                attributes #0 = { alwaysinline }
-            """, "entry"),Float64,Tuple{})
-    end
-    @test do_the_call() === 42.0
-end
-
 # Issue #48093 - test that non-external globals are not deduplicated
 function kernel()
     Base.llvmcall(("""
diff --git a/test/precompile.jl b/test/precompile.jl
index 50686d0b47cb9..e118c7a8ee4bf 100644
--- a/test/precompile.jl
+++ b/test/precompile.jl
@@ -1,7 +1,7 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
 
-using Test, Distributed, Random, Logging
-using REPL # doc lookup function
+using Test, Distributed, Random, Logging, Libdl
+using REPL # testing the doc lookup function should be outside of the scope of this file, but is currently tested here
 
 include("precompile_utils.jl")
 
@@ -392,36 +392,27 @@ precompile_test_harness(false) do dir
         @test Base.object_build_id(Foo.a_vec_int) == Base.module_build_id(Foo)
     end
 
-    @eval begin function ccallable_test()
-        Base.llvmcall(
-        ("""declare i32 @f35014(i32)
-            define i32 @entry() {
-            0:
-                %1 = call i32 @f35014(i32 3)
-                ret i32 %1
-            }""", "entry"
-        ), Cint, Tuple{})
-    end
-    @test ccallable_test() == 4
-    end
-
     cachedir = joinpath(dir, "compiled", "v$(VERSION.major).$(VERSION.minor)")
     cachedir2 = joinpath(dir2, "compiled", "v$(VERSION.major).$(VERSION.minor)")
     cachefile = joinpath(cachedir, "$Foo_module.ji")
+    @test isfile(cachefile)
     do_pkgimg = Base.JLOptions().use_pkgimages == 1 && Base.JLOptions().permalloc_pkgimg == 1
     if do_pkgimg ||  Base.JLOptions().use_pkgimages == 0
         if do_pkgimg
-            ocachefile = Base.ocachefile_from_cachefile(cachefile)
+            ocachefile = Base.ocachefile_from_cachefile(cachefile)::String
+            @test isfile(ocachefile)
+            let foo_ptr = Libdl.dlopen(ocachefile::String, RTLD_NOLOAD)
+                f35014_ptr = Libdl.dlsym(foo_ptr, :f35014)
+                @test ccall(f35014_ptr, Int32, (Int32,), 3) == 4
+            end
         else
             ocachefile = nothing
         end
         # use _require_from_serialized to ensure that the test fails if
         # the module doesn't reload from the image:
-        @test_warn "@ccallable was already defined for this method name" begin
-            @test_logs (:warn, "Replacing module `$Foo_module`") begin
-                m = Base._require_from_serialized(Base.PkgId(Foo), cachefile, ocachefile, Foo_file)
-                @test isa(m, Module)
-            end
+        @test_logs (:warn, "Replacing module `$Foo_module`") begin
+            m = Base._require_from_serialized(Base.PkgId(Foo), cachefile, ocachefile, Foo_file)
+            @test isa(m, Module)
         end
     end