Allow ScopedValue defaults to be lazily computed (#59372)

Author: Keno

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/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()

stdlib/Test/src/Test.jl

@@ -29,11 +29,7 @@ using Random: AbstractRNG, default_rng
 using InteractiveUtils: gen_call_with_extracted_types
 using Base: typesplit, remove_linenums!
 using Serialization: Serialization
-using Base.ScopedValues: ScopedValue, @with
-
-const record_passes = OncePerProcess{Bool}() do
-    return Base.get_bool_env("JULIA_TEST_RECORD_PASSES", false)
-end
+using Base.ScopedValues: LazyScopedValue, ScopedValue, @with
 
 const global_fail_fast = OncePerProcess{Bool}() do
     return Base.get_bool_env("JULIA_TEST_FAILFAST", false)
@@ -1253,10 +1249,11 @@ struct FailFastError <: Exception end
 # For a broken result, simply store the result
 record(ts::DefaultTestSet, t::Broken) = ((@lock ts.results_lock push!(ts.results, t)); t)
 # For a passed result, do not store the result since it uses a lot of memory, unless
-# `record_passes()` is true. i.e. set env var `JULIA_TEST_RECORD_PASSES=true` before running any testsets
+# `TEST_RECORD_PASSES[]` is true. i.e. overridden by scoped value or with env var
+# `JULIA_TEST_RECORD_PASSES=true` set in the environment.
 function record(ts::DefaultTestSet, t::Pass)
     @atomic :monotonic ts.n_passed += 1
-    if record_passes()
+    if TEST_RECORD_PASSES[]
         # throw away the captured data so it can be GC-ed
         t_nodata = Pass(t.test_type, t.orig_expr, nothing, t.value, t.source, t.message_only)
         @lock ts.results_lock push!(ts.results, t_nodata)
@@ -2103,6 +2100,9 @@ end
 const CURRENT_TESTSET = ScopedValue{AbstractTestSet}(FallbackTestSet())
 const TESTSET_DEPTH = ScopedValue{Int}(0)
 const TESTSET_PRINT_ENABLE = ScopedValue{Bool}(true)
+const TEST_RECORD_PASSES = LazyScopedValue{Bool}(OncePerProcess{Bool}() do
+    return Base.get_bool_env("JULIA_TEST_RECORD_PASSES", false)
+end)
 
 macro with_testset(ts, expr)
     :(@with(CURRENT_TESTSET => $(esc(ts)), TESTSET_DEPTH => get_testset_depth() + 1, $(esc(expr))))

test/scopedvalues.jl

@@ -197,3 +197,15 @@ nothrow_scope(Core.current_scope())
         push!(ts, 2)
     end
 end
+
+# LazyScopedValue
+global lsv_ncalled = 0
+const lsv = LazyScopedValue{Int}(OncePerProcess(() -> (global lsv_ncalled; lsv_ncalled += 1; 1)))
+@testset "LazyScopedValue" begin
+    @test (@with lsv=>2 lsv[]) == 2
+    @test lsv_ncalled == 0
+    @test lsv[] == 1
+    @test lsv_ncalled == 1
+    @test lsv[] == 1
+    @test lsv_ncalled == 1
+end

test/testdefs.jl

@@ -5,11 +5,10 @@ using Test, Random
 include("buildkitetestjson.jl")
 
 function runtests(name, path, isolate=true; seed=nothing)
-    @Base.ScopedValues.with Test.TESTSET_PRINT_ENABLE=>false begin
+    @Base.ScopedValues.with Test.TESTSET_PRINT_ENABLE=>false Test.TEST_RECORD_PASSES=>Base.get_bool_env("CI", false) begin
     # remove all hint_handlers, so that errorshow tests are not changed by which packages have been loaded on this worker already
     # packages that call register_error_hint should also call this again, and then re-add any hooks they want to test
     empty!(Base.Experimental._hint_handlers)
-    withenv("JULIA_TEST_RECORD_PASSES" => Base.get_bool_env("CI", false)) do
     try
         if isolate
             # Simple enough to type and random enough so that no one will hard
@@ -105,7 +104,6 @@ function runtests(name, path, isolate=true; seed=nothing)
         ex isa TestSetException || rethrow()
         return Any[ex]
     end
-    end # withenv
     end # TESET_PRINT_ENABLE
 end