Merge branch 'master' into eliminate_some_Array-specific_methods_of_size

Author: nsajko

.github/workflows/Typos.yml

@@ -11,7 +11,7 @@ jobs:
     timeout-minutes: 5
     steps:
       - name: Checkout the JuliaLang/julia repository
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
         with:
           persist-credentials: false
       - name: Check spelling with typos

.github/workflows/Whitespace.yml

@@ -15,7 +15,7 @@ jobs:
     timeout-minutes: 2
     steps:
       - name: Checkout the JuliaLang/julia repository
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
         with:
           persist-credentials: false
       - uses: julia-actions/setup-julia@5c9647d97b78a5debe5164e9eec09d653d29bd71 # v2.6.1

.github/workflows/cffconvert.yml

@@ -23,7 +23,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Check out a copy of the repository
-        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
         with:
           persist-credentials: false
 

Compiler/src/ssair/show.jl

@@ -301,7 +301,7 @@ function compute_ir_line_annotations(code::Union{IRCode,CodeInfo})
             x = min(length(last_stack), length(stack))
             depth = length(stack) - 1
             # Compute the last depth that was in common
-            first_mismatch = let last_stack=last_stack
+            first_mismatch = let last_stack=last_stack, stack=stack
                 findfirst(i->last_stack[i] != stack[i], 1:x)
             end
             # If the first mismatch is the last stack frame, that might just

NEWS.md

@@ -67,6 +67,9 @@ New library features
   migrate now by calling `legacyscope=false` or using `macroexpand!`. This may often require
   fixes to the code calling `macroexpand` with `Meta.unescape` and `Meta.reescape` or by
   updating tests to expect `hygienic-scope` or `escape` markers might appear in the result.
+* `Base.ScopedValues.LazyScopedValue{T}` is introduced for scoped values that compute their default using a
+  `OncePerProcess{T}` callback, allowing for lazy initialization of the default value. `AbstractScopedValue` is
+  now the abstract base type for both `ScopedValue` and `LazyScopedValue`. ([#59372])
 
 Standard library changes
 ------------------------

base/abstractset.jl

@@ -201,7 +201,7 @@ intersect!(s::AbstractSet, itr) =
     setdiff(s, itrs...)
 
 Construct the set of elements in `s` but not in any of the iterables in `itrs`.
-Maintain order with arrays.
+Maintain order with arrays. The result will have the same element type as `s`.
 
 See also [`setdiff!`](@ref), [`union`](@ref) and [`intersect`](@ref).
 
@@ -211,6 +211,10 @@ julia> setdiff([1,2,3], [3,4,5])
 2-element Vector{Int64}:
  1
  2
+
+julia> setdiff([1,2,3], [1.0, 2.0])
+1-element Vector{Int64}:
+ 3
 ```
 """
 setdiff(s::AbstractSet, itrs...) = setdiff!(copymutable(s), itrs...)

base/array.jl

@@ -3126,14 +3126,17 @@ setdiff!(  v::AbstractVector, itrs...) = _shrink!(setdiff!, v, itrs)
 
 vectorfilter(T::Type, f, v) = T[x for x in v if f(x)]
 
-function _shrink(shrinker!::F, itr, itrs) where F
+function intersect(itr, itrs...)
     T = promote_eltype(itr, itrs...)
-    keep = shrinker!(Set{T}(itr), itrs...)
+    keep = intersect!(Set{T}(itr), itrs...)
     vectorfilter(T, _shrink_filter!(keep), itr)
 end
 
-intersect(itr, itrs...) = _shrink(intersect!, itr, itrs)
-setdiff(  itr, itrs...) = _shrink(setdiff!, itr, itrs)
+function setdiff(itr, itrs...)
+    T = eltype(itr)
+    keep = setdiff!(Set{T}(itr), itrs...)
+    vectorfilter(T, _shrink_filter!(keep), itr)
+end
 
 function intersect(v::AbstractVector, r::AbstractRange)
     T = promote_eltype(v, r)

base/indices.jl

@@ -385,10 +385,9 @@ end
 Slice(S::Slice) = S
 Slice{T}(S::Slice) where {T<:AbstractUnitRange} = Slice{T}(T(S.indices))
 
-axes(S::Slice) = (IdentityUnitRange(S.indices),)
+axes(S::Slice) = (axes1(S),)
 axes1(S::Slice) = IdentityUnitRange(S.indices)
-axes(S::Slice{<:OneTo}) = (S.indices,)
-axes1(S::Slice{<:OneTo}) = S.indices
+axes1(S::Slice{<:AbstractOneTo{<:Integer}}) = S.indices
 
 first(S::Slice) = first(S.indices)
 last(S::Slice) = last(S.indices)
@@ -414,10 +413,9 @@ IdentityUnitRange(S::IdentityUnitRange) = S
 IdentityUnitRange{T}(S::IdentityUnitRange) where {T<:AbstractUnitRange} = IdentityUnitRange{T}(T(S.indices))
 
 # IdentityUnitRanges are offset and thus have offset axes, so they are their own axes
-axes(S::IdentityUnitRange) = (S,)
+axes(S::IdentityUnitRange) = (axes1(S),)
 axes1(S::IdentityUnitRange) = S
-axes(S::IdentityUnitRange{<:OneTo}) = (S.indices,)
-axes1(S::IdentityUnitRange{<:OneTo}) = S.indices
+axes1(S::IdentityUnitRange{<:AbstractOneTo{<:Integer}}) = S.indices
 
 first(S::IdentityUnitRange) = first(S.indices)
 last(S::IdentityUnitRange) = last(S.indices)
@@ -465,11 +463,11 @@ end
 show(io::IO, r::IdentityUnitRange) = print(io, "Base.IdentityUnitRange(", r.indices, ")")
 iterate(S::IdentityUnitRange, s...) = iterate(S.indices, s...)
 
-# For OneTo, the values and indices of the values are identical, so this may be defined in Base.
+# For AbstractOneTo, the values and indices of the values are identical, so this may be defined in Base.
 # In general such an indexing operation would produce offset ranges
 # This should also ideally return an AbstractUnitRange{eltype(S)}, but currently
 # we're restricted to eltype(::IdentityUnitRange) == Int by definition
-function getindex(S::OneTo, I::IdentityUnitRange{<:AbstractUnitRange{<:Integer}})
+function getindex(S::AbstractOneTo{<:Integer}, I::IdentityUnitRange{<:AbstractUnitRange{<:Integer}})
     @inline
     @boundscheck checkbounds(S, I)
     return I

base/scopedvalues.jl

@@ -2,9 +2,57 @@
 
 module ScopedValues
 
-export ScopedValue, with, @with
+export ScopedValue, LazyScopedValue, with, @with
 public get
 
+"""
+    AbstractScopedValue{T}
+
+Abstract base type for scoped values that propagate values across
+dynamic scopes. All scoped value types must extend this abstract type.
+
+See also: [`ScopedValue`](@ref), [`LazyScopedValue`](@ref)
+
+!!! compat "Julia 1.13"
+    AbstractScopedValue requires Julia 1.13+.
+"""
+abstract type AbstractScopedValue{T} end
+
+
+"""
+    LazyScopedValue{T}(f::OncePerProcess{T})
+
+A scoped value that uses an `OncePerProcess{T}` to lazily compute its default value
+when none has been set in the current scope. Unlike `ScopedValue`, the default is
+not evaluated at construction time but only when first accessed.
+
+# Examples
+
+```julia-repl
+julia> using Base.ScopedValues;
+
+julia> const editor = LazyScopedValue(OncePerProcess(() -> ENV["JULIA_EDITOR"]));
+
+julia> editor[]
+"vim"
+
+julia> with(editor => "emacs") do
+           sval[]
+       end
+"emacs"
+
+julia> editor[]
+"vim"
+```
+
+!!! compat "Julia 1.13"
+    LazyScopedValue requires Julia 1.13+.
+"""
+mutable struct LazyScopedValue{T} <: AbstractScopedValue{T}
+    const getdefault::OncePerProcess{T}
+end
+
+
 """
     ScopedValue(x)
 
@@ -40,17 +88,23 @@ julia> sval[]
     Scoped values were introduced in Julia 1.11. In Julia 1.8+ a compatible
     implementation is available from the package ScopedValues.jl.
 """
-mutable struct ScopedValue{T}
+mutable struct ScopedValue{T} <: AbstractScopedValue{T}
     # NOTE this struct must be defined as mutable one since it's used as a key of
     #      `ScopeStorage` dictionary and thus needs object identity
-    const has_default::Bool # this field is necessary since isbitstype `default` field may be initialized with undefined value
+    const hasdefault::Bool # this field is necessary since isbitstype `default` field may be initialized with undefined value
     const default::T
-    ScopedValue{T}() where T = new(false)
+    ScopedValue{T}() where T = new{T}(false)
     ScopedValue{T}(val) where T = new{T}(true, val)
     ScopedValue(val::T) where T = new{T}(true, val)
 end
 
-Base.eltype(::ScopedValue{T}) where {T} = T
+Base.eltype(::AbstractScopedValue{T}) where {T} = T
+
+hasdefault(val::ScopedValue) = val.hasdefault
+hasdefault(val::LazyScopedValue) = true
+
+getdefault(val::ScopedValue) = val.hasdefault ? val.default : throw(KeyError(val))
+getdefault(val::LazyScopedValue) = val.getdefault()
 
 """
     isassigned(val::ScopedValue)
@@ -72,34 +126,34 @@ julia> isassigned(b)
 false
 ```
 """
-function Base.isassigned(val::ScopedValue)
-    val.has_default && return true
+function Base.isassigned(val::AbstractScopedValue)
+    hasdefault(val) && return true
     scope = Core.current_scope()::Union{Scope, Nothing}
     scope === nothing && return false
     return haskey((scope::Scope).values, val)
 end
 
-const ScopeStorage = Base.PersistentDict{ScopedValue, Any}
+const ScopeStorage = Base.PersistentDict{AbstractScopedValue, Any}
 
 struct Scope
     values::ScopeStorage
 end
 
 Scope(scope::Scope) = scope
 
-function Scope(parent::Union{Nothing, Scope}, key::ScopedValue{T}, value) where T
+function Scope(parent::Union{Nothing, Scope}, key::AbstractScopedValue{T}, value) where T
     val = convert(T, value)
     if parent === nothing
         return Scope(ScopeStorage(key=>val))
     end
     return Scope(ScopeStorage(parent.values, key=>val))
 end
 
-function Scope(scope, pair::Pair{<:ScopedValue})
+function Scope(scope, pair::Pair{<:AbstractScopedValue})
     return Scope(scope, pair...)
 end
 
-function Scope(scope, pair1::Pair{<:ScopedValue}, pair2::Pair{<:ScopedValue}, pairs::Pair{<:ScopedValue}...)
+function Scope(scope, pair1::Pair{<:AbstractScopedValue}, pair2::Pair{<:AbstractScopedValue}, pairs::Pair{<:AbstractScopedValue}...)
     # Unroll this loop through recursion to make sure that
     # our compiler optimization support works
     return Scope(Scope(scope, pair1...), pair2, pairs...)
@@ -115,19 +169,17 @@ function Base.show(io::IO, scope::Scope)
         else
             print(io, ", ")
         end
-        print(io, typeof(key), "@")
+        print(io, isa(key, ScopedValue) ? ScopedValue{eltype(key)} : typeof(key), "@")
         show(io, Base.objectid(key))
         print(io, " => ")
         show(IOContext(io, :typeinfo => eltype(key)), value)
     end
     print(io, ")")
 end
 
-struct NoValue end
-const novalue = NoValue()
-
 """
     get(val::ScopedValue{T})::Union{Nothing, Some{T}}
+    get(val::LazyScopedValue{T})::Union{Nothing, Some{T}}
 
 If the scoped value isn't set and doesn't have a default value,
 return `nothing`. Otherwise returns `Some{T}` with the current
@@ -148,31 +200,36 @@ julia> isnothing(ScopedValues.get(b))
 true
 ```
 """
-function get(val::ScopedValue{T}) where {T}
+function get(val::AbstractScopedValue{T}) where {T}
     scope = Core.current_scope()::Union{Scope, Nothing}
     if scope === nothing
-        val.has_default && return Some{T}(val.default)
-        return nothing
+        !hasdefault(val) && return nothing
+        return Some{T}(getdefault(val))
     end
     scope = scope::Scope
-    if val.has_default
-        return Some{T}(Base.get(scope.values, val, val.default)::T)
+    if hasdefault(val)
+        return Some{T}(Base.get(Base.Fix1(getdefault, val), scope.values, val)::T)
     else
-        v = Base.get(scope.values, val, novalue)
-        v === novalue || return Some{T}(v::T)
+        v = Base.KeyValue.get(scope.values, val)
+        v === nothing && return nothing
+        return Some{T}(only(v)::T)
     end
     return nothing
 end
 
-function Base.getindex(val::ScopedValue{T})::T where T
+function Base.getindex(val::AbstractScopedValue{T})::T where T
     maybe = get(val)
     maybe === nothing && throw(KeyError(val))
     return something(maybe)::T
 end
 
-function Base.show(io::IO, val::ScopedValue)
-    print(io, ScopedValue)
-    print(io, '{', eltype(val), '}')
+function Base.show(io::IO, val::AbstractScopedValue)
+    if isa(val, ScopedValue)
+        print(io, ScopedValue)
+        print(io, '{', eltype(val), '}')
+    else
+        print(io, typeof(val))
+    end
     print(io, '(')
     v = get(val)
     if v === nothing
@@ -265,7 +322,7 @@ julia> with(() -> a[] * b[], a=>3, b=>4)
 12
 ```
 """
-function with(f, pair::Pair{<:ScopedValue}, rest::Pair{<:ScopedValue}...)
+function with(f, pair::Pair{<:AbstractScopedValue}, rest::Pair{<:AbstractScopedValue}...)
     @with(pair, rest..., f())
 end
 with(@nospecialize(f)) = f()

deps/checksums/SparseArrays-6fe51f204d6be98d79431f6ae7d08b9a6527740f.tar.gz/md5

@@ -0,0 +1 @@
+4ca411efb3c84aa309965fbc749d12aa