ids: use directly testset trees instead of a stack

Author: rfourquet

src/ReTest.jl

@@ -90,6 +90,15 @@ end
 isfor(ts::TestsetExpr) = ts.loops !== nothing
 isfinal(ts::TestsetExpr) = isempty(ts.children)
 
+function tsdepth(ts::Union{TestsetExpr,Testset.ReTestSet})
+    d = 1
+    while ts.parent !== nothing
+        d += 1
+        ts = ts.parent
+    end
+    d
+end
+
 struct _Invalid
     global const invalid = _Invalid.instance
 end
@@ -215,7 +224,7 @@ end
 function resolve!(mod::Module, ts::TestsetExpr, pat::Pattern;
                   # external calls
                   verbose::Int, id::Int64, strict::Bool, static::Maybe{Bool},
-                  ids::Vector{Int64}, warned::Ref{Bool},
+                  warned::Ref{Bool},
                    # only recursive calls
                   force::Bool=false, shown::Bool=true, depth::Int=0)
 
@@ -229,9 +238,8 @@ function resolve!(mod::Module, ts::TestsetExpr, pat::Pattern;
         warned[] = true
     end
     ts.id = id
-    push!(ids, id)
     id += 1
-    ts.run = force | (static !== false) & alwaysmatches(pat, length(ids))
+    ts.run = force | (static !== false) & alwaysmatches(pat, tsdepth(ts))
 
     parentstrs = ts.parent === nothing ? [""] : ts.parent.strings
     ts.descwidth = 0
@@ -256,7 +264,7 @@ function resolve!(mod::Module, ts::TestsetExpr, pat::Pattern;
         end
 
     function decide(subj)
-        m = matches(pat, subj, ids)
+        m = matches(pat, subj, ts)
         # For the curious reader, setting `s = something(static, missing)`, there
         # are few "formulas" to compute the result without `if`, but using only
         # `coalesce, |, &, ==, !=, ===, !==, (a,b) -> a, (a,b) -> b, (a,b) -> !a,
@@ -367,15 +375,14 @@ function resolve!(mod::Module, ts::TestsetExpr, pat::Pattern;
         runc, id = resolve!(mod, tsc, pat, force = !strict && ts.run,
                             shown=shown & ts.options.transient_verbose, static=static,
                             depth=depth+1, verbose=verbose-1, id=id, strict=strict,
-                            ids=ids, warned=warned)
+                            warned=warned)
         run |= runc
         ts.descwidth = max(ts.descwidth, tsc.descwidth)
         if tsc.run
             ts.hasbrokenrec |= tsc.hasbrokenrec
         end
     end
 
-    pop!(ids)
     if !run || !shown
         ts.descwidth = 0
     end
@@ -1285,12 +1292,11 @@ function fetchtests((mod, pat), verbose, module_header, maxidw; static, strict,
     hasbroken = false
 
     id = 1
-    ids = Int64[]
     warned = Ref(false)
 
     for ts in tests
         run, id = resolve!(mod, ts, pat, verbose=verbose, id=id, strict=strict,
-                           static=static, ids=ids, warned=warned)
+                           static=static, warned=warned)
         run || continue
         descwidth = max(descwidth, ts.descwidth)
         hasbroken |= ts.hasbrokenrec
@@ -1323,12 +1329,11 @@ hasmany(tests) = length(tests) > 1 || isfor(tests[1])
 function dryrun(mod::Module, ts::TestsetExpr, pat::Pattern, align::Int=0, parentsubj=""
                 ; maxidw::Int, marks::Bool, # external calls
                 # only recursive calls:
-                evaldesc=true, repeated=nothing, ids::Vector{Int64}=Int64[], show::Bool=true)
+                evaldesc=true, repeated=nothing, show::Bool=true)
     @assert ts.run
     desc = ts.desc
 
     if ts.loops === nothing
-        push!(ids, ts.id)
         if evaldesc && !(desc isa String)
             try
                 desc = Core.eval(mod, desc)
@@ -1339,8 +1344,7 @@ function dryrun(mod::Module, ts::TestsetExpr, pat::Pattern, align::Int=0, parent
         subject = nothing
         if parentsubj isa String && desc isa String
             subject = parentsubj * '/' * desc
-            if isfinal(ts) && !matches(pat, subject, ids)
-                pop!(ids)
+            if isfinal(ts) && !matches(pat, subject, ts)
                 return false, false, false
             end
         end
@@ -1371,9 +1375,8 @@ function dryrun(mod::Module, ts::TestsetExpr, pat::Pattern, align::Int=0, parent
             for tsc in ts.children
                 tsc.run || continue
                 dryrun(mod, tsc, pat, align + 2, subject,
-                       maxidw=maxidw, marks=marks, ids=ids, show=true)
+                       maxidw=maxidw, marks=marks, show=true)
             end
-            pop!(ids)
             false, false, false # meaningless unused triple
         elseif marks
             passes, fails, unrun = false, false, false
@@ -1389,13 +1392,12 @@ function dryrun(mod::Module, ts::TestsetExpr, pat::Pattern, align::Int=0, parent
             for tsc in ts.children
                 tsc.run || continue
                 cp, cf, cu = dryrun(mod, tsc, pat, align + 2, subject,
-                                    maxidw=maxidw, marks=marks, ids=ids, show=false)
+                                    maxidw=maxidw, marks=marks, show=false)
                 passes |= cp
                 fails |= cf
                 unrun |= cu
                 passes && fails && unrun && break
             end
-            pop!(ids)
             if show
                 passes &&
                     printstyled(" ✅", color = :light_black, bold=true)
@@ -1412,7 +1414,6 @@ function dryrun(mod::Module, ts::TestsetExpr, pat::Pattern, align::Int=0, parent
             if show
                 println()
             end
-            pop!(ids)
             false, false, false
         end
     else
@@ -1438,7 +1439,7 @@ function dryrun(mod::Module, ts::TestsetExpr, pat::Pattern, align::Int=0, parent
             beginend.id = ts.id
             beginend.results = ts.results
             dryrun(mod, beginend, pat, align, parentsubj; evaldesc=false,
-                   repeated=repeated, maxidw=maxidw, marks=marks, ids=ids, show=show)
+                   repeated=repeated, maxidw=maxidw, marks=marks, show=show)
         end
 
         loopvalues = ts.loopvalues

src/patterns.jl

@@ -79,41 +79,42 @@ alwaysmatches(dep::Depth, d) = dep.d == d
 
 ## matches
 
-matches(pat::And, x, ids) = all(p -> matches(p, x, ids), pat.xs)
+matches(pat::And, x, ts) = all(p -> matches(p, x, ts), pat.xs)
 
-matches(pat::Or, x, ids) =
+matches(pat::Or, x, ts) =
     if pat.xs isa AbstractUnitRange{<:Integer} && minimum(pat.xs) >= 0
-        ids[end] ∈ pat.xs # this is optimised, i.e. it's not O(n)
+        ts.id ∈ pat.xs # this is optimised, i.e. it's not O(n)
     else
-        any(p -> matches(p, x, ids), pat.xs)
+        any(p -> matches(p, x, ts), pat.xs)
     end
 
-matches(pat::Not, x, ids) = !matches(pat.x, x, ids)
-matches(::Interpolated, x::Union{Missing,AbstractString}, ids) = x !== missing
+matches(pat::Not, x, ts) = !matches(pat.x, x, ts)
+matches(::Interpolated, x::Union{Missing,AbstractString}, ts) = x !== missing
 matches(rx::Regex, x, _) = occursin(rx, x)
-matches(rx::Regex, ::Missing, ids) = alwaysmatches(rx, length(ids)) | missing
-matches(pat::Integer, _, ids) =
+matches(rx::Regex, ::Missing, ts) = alwaysmatches(rx, tsdepth(ts)) | missing
+matches(pat::Integer, _, ts) =
     @inbounds pat >= 0 ?
-        pat == ids[end] :
-        pat != -ids[end]
+        pat == ts.id :
+        pat != -ts.id
 
-function matches(pat::Reachable, desc, ids::Vector{Int64})
+function matches(pat::Reachable, desc, ts)
     if desc !== missing
         desc = SubString(desc)
     end
     m = false
-    for d = length(ids):-1:1
-        @inbounds id = ids[d]
-        m |= matches(pat.x, desc, @view ids[1:d])
+    while true
+        m |= matches(pat.x, desc, ts)
         m === true && return true
+        ts.parent === nothing && break
+        ts = ts.parent
         if desc !== missing
             desc = SubString(desc, 1, findlast('/', desc)-1)
         end
     end
     m
 end
 
-matches(d::Depth, _, ids) = d.d == length(ids)
+matches(d::Depth, _, ts) = d.d == tsdepth(ts)
 
 
 ## make_pattern

src/testset.jl

@@ -60,9 +60,10 @@ Format(stats, desc_align) = Format(stats, desc_align, 0, 0, 0,0 ,0)
 
 mutable struct ReTestSet <: AbstractTestSet
     mod::Module # enclosing module
-    description::AbstractString
+    parent::Union{Nothing,ReTestSet}
+    description::String
+    subject::String
     id::Int64
-    ids::Vector{Int64} # shared instance in an id stack
     overall::Bool # TODO: could be conveyed by having self.mod == ""
     results::Vector
     n_passed::Int
@@ -72,8 +73,13 @@ mutable struct ReTestSet <: AbstractTestSet
     exception::Union{TestSetException,Nothing}
 end
 
-ReTestSet(mod, desc, id::Integer=0; ids=Int64[], overall=false, verbose=true) =
-    ReTestSet(mod, desc, id, ids, overall, [], 0, false, verbose, NamedTuple(), nothing)
+function ReTestSet(mod, desc::String, id::Integer=0;
+                   overall=false, verbose=true, parent=nothing)
+    parentsubj = parent === nothing ? "" : parent.subject
+    subject = string(parentsubj, '/', desc)
+    ReTestSet(mod, parent, desc, subject, id, overall, [], 0, false,
+              verbose, NamedTuple(), nothing)
+end
 
 # For a non-passed result, simply store the result
 record(ts::ReTestSet, t::Union{Broken,Fail,Error}) = (push!(ts.results, t); t)
@@ -437,11 +443,12 @@ default_rng() = isdefined(Random, :default_rng) ?
     Random.default_rng() :
     Random.GLOBAL_RNG
 
-function get_testset_ids_string(remove_last=false)
+function make_retestset(mod, desc, id, verbose, remove_last=false)
     _testsets = get(task_local_storage(), :__BASETESTNEXT__, Test.AbstractTestSet[])
+    @assert !(remove_last && isempty(_testsets))
     testsets = @view _testsets[1:end-remove_last]
-    (isempty(testsets) ? Int64[] : resize!(testsets[end].ids, length(testsets)),
-     join('/' * ts.description for ts in testsets))
+    ReTestSet(mod, desc, id; verbose=verbose,
+              parent = isempty(testsets) ? nothing : testsets[end])
 end
 
 # HACK: we re-use the same macro name `@testset` for actual execution (like in `Test`)
@@ -483,13 +490,10 @@ function testset_beginend(mod::Module, isfinal::Bool, pat::Pattern, id::Int64, d
     # action (such as reporting the results)
     desc = esc(desc)
     ex = quote
-        local ids, current_str = get_testset_ids_string()
-        current_str = string(current_str, '/', $desc)
-        push!(ids, $id)
-        if !$isfinal || matches($pat, current_str, ids)
+        local ts = make_retestset($mod, $desc, $id, $(options.transient_verbose))
+
+        if !$isfinal || matches($pat, ts.subject, ts)
             local ret
-            local ts = ReTestSet($mod, $desc, $id; verbose=$(options.transient_verbose),
-                                 ids=ids)
             if nworkers() == 1 && get_testset_depth() == 0 && $(chan.preview) !== nothing
                 put!($(chan.preview), $desc)
             end
@@ -517,7 +521,7 @@ function testset_beginend(mod::Module, isfinal::Bool, pat::Pattern, id::Int64, d
                                  Base.catch_stack(), $(QuoteNode(source))))
             finally
                 copy!(RNG, oldrng)
-                $results[current_str] = !anyfailed(ts)
+                $results[ts.subject] = !anyfailed(ts)
                 pop_testset()
                 ret = finish(ts, $chan)
             end
@@ -542,11 +546,10 @@ function testset_forloop(mod::Module, isfinal::Bool, pat::Pattern, id::Int64,
 
     desc = esc(desc)
     blk = quote
-        local ids, current_str = get_testset_ids_string(!first_iteration)
-        current_str = string(current_str, '/', $desc)
-        push!(ids, $id)
+        local ts0 = make_retestset($mod, $desc, $id, $(options.transient_verbose),
+                                   !first_iteration)
 
-        if !$isfinal || matches($pat, current_str, ids)
+        if !$isfinal || matches($pat, ts0.subject, ts0)
             # Trick to handle `break` and `continue` in the test code before
             # they can be handled properly by `finally` lowering.
             if !first_iteration
@@ -555,8 +558,7 @@ function testset_forloop(mod::Module, isfinal::Bool, pat::Pattern, id::Int64,
                 # it's 1000 times faster to copy from tmprng rather than calling Random.seed!
                 copy!(RNG, tmprng)
             end
-            ts = ReTestSet($mod, $desc, $id; verbose=$(options.transient_verbose),
-                           ids=ids)
+            ts = ts0
             if nworkers() == 1 && get_testset_depth() == 0 && $(chan.preview) !== nothing
                 put!($(chan.preview), ts.description)
             end
@@ -566,13 +568,13 @@ function testset_forloop(mod::Module, isfinal::Bool, pat::Pattern, id::Int64,
                 let
                     ts.timed = @stats $stats $(esc(tests))
                 end
-                $results[current_str] = !anyfailed(ts)
+                $results[ts.subject] = !anyfailed(ts)
             catch err
                 err isa InterruptException && rethrow()
                 # Something in the test block threw an error. Count that as an
                 # error in this test set
                 record(ts, Error(:nontest_error, Expr(:tuple), err, Base.catch_stack(), $(QuoteNode(source))))
-                $results[current_str] = false
+                $results[ts.subject] = false
             end
         end
     end