move the contrib script to Test

Author: KristofferC

contrib/scan-closure-boxes.jl

@@ -420,6 +420,7 @@ Test.GenericOrder
 Test.GenericSet
 Test.GenericString
 Test.detect_ambiguities
+Test.detect_closure_boxes
 Test.detect_unbound_args
 ```
 

stdlib/Test/docs/src/index.md

@@ -26,7 +26,7 @@ export @test, @test_throws, @test_broken, @test_skip,
 
 export @testset
 export @inferred
-export detect_ambiguities, detect_unbound_args
+export detect_ambiguities, detect_unbound_args, detect_closure_boxes
 export GenericString, GenericSet, GenericDict, GenericArray, GenericOrder
 export TestSetException
 export TestLogger, LogRecord
@@ -2527,7 +2527,7 @@ function detect_ambiguities(mods::Module...;
                             allowed_undefineds = nothing)
     @nospecialize
     ambs = Set{Tuple{Method,Method}}()
-    mods = collect(mods)::Vector{Module}
+    mods = Module[mods...]
     function sortdefs(m1::Method, m2::Method)
         ord12 = cmp(m1.file, m2.file)
         if ord12 == 0
@@ -2557,6 +2557,90 @@ function detect_ambiguities(mods::Module...;
     return collect(ambs)
 end
 
+"""
+    detect_closure_boxes(mod1, mod2...; recursive=false)
+
+Return a vector of `(Method, varname)` pairs for methods defined in the specified
+modules that allocate `Core.Box` in their lowered code. If `recursive=false`,
+each module is treated as a root module (for example, `Base` matches
+`Base.Compiler`), but submodules of non-root modules are excluded. Use
+`recursive=true` to include submodules of the specified modules. The returned
+`varname` is a `Symbol`, or `:unknown` when a slot name cannot be resolved.
+"""
+function detect_closure_boxes(mods::Module...; recursive::Bool = false)
+    @nospecialize
+    boxes = Tuple{Method,Symbol}[]
+    mods = Module[mods...]
+    isempty(mods) && return boxes
+
+    function is_box_call(expr)
+        if !(expr isa Expr)
+            return false
+        end
+        if expr.head === :call || expr.head === :new
+            callee = expr.args[1]
+            return callee === Core.Box || (callee isa GlobalRef && callee.mod === Core && callee.name === :Box)
+        end
+        return false
+    end
+
+    function slot_name(ci, slot)::Symbol
+        if slot isa Core.SlotNumber
+            idx = Int(slot.id)
+            if 1 <= idx <= length(ci.slotnames)
+                return ci.slotnames[idx]
+            end
+        end
+        return Symbol(string(slot))
+    end
+
+    function root_module(mod::Module)
+        while true
+            parent = parentmodule(mod)
+            if parent === mod || parent === Main || parent === Core
+                return mod
+            end
+            mod = parent
+        end
+    end
+
+    function matches_module(mod::Module)
+        mod in mods && return true
+        recursive && return is_in_mods(mod, true, mods)
+        return root_module(mod) in mods
+    end
+
+    function scan_method!(m::Method)
+        matches_module(parentmodule(m)) || return
+        ci = try
+            Base.uncompressed_ast(m)
+        catch
+            return
+        end
+        for stmt in ci.code
+            if stmt isa Expr && stmt.head === :(=)
+                lhs = stmt.args[1]
+                rhs = stmt.args[2]
+                if is_box_call(rhs)
+                    push!(boxes, (m, slot_name(ci, lhs)))
+                end
+            elseif is_box_call(stmt)
+                    push!(boxes, (m, :unknown))
+            end
+        end
+    end
+
+    Base.visit(Core.methodtable) do m
+        scan_method!(m)
+    end
+
+    sort!(boxes, by = entry -> begin
+        m, var = entry
+        (m.file, m.line, var, m.name, m.sig)
+    end)
+    return boxes
+end
+
 """
     detect_unbound_args(mod1, mod2...; recursive=false, allowed_undefineds=nothing)
 
@@ -2583,7 +2667,7 @@ function detect_unbound_args(mods...;
                              allowed_undefineds=nothing)
     @nospecialize mods
     ambs = Set{Method}()
-    mods = collect(mods)::Vector{Module}
+    mods = Module[mods...]
     function examine(mt::Core.MethodTable)
         for m in Base.MethodList(mt)
             is_in_mods(parentmodule(m), recursive, mods) || continue

stdlib/Test/src/Test.jl

@@ -29,6 +29,36 @@ import Logging: Debug, Info, Warn, with_logger
     @test 'a' .. 'a'
     @test !('a' .. 'b')
 end
+
+
+module ClosureBoxTest
+    function boxed()
+        x = 1
+        inner() = (x += 1)
+        inner()
+    end
+
+    module Sub
+        function boxed_sub()
+            x = 0
+            inner() = (x += 1)
+            inner()
+        end
+    end
+end
+
+@testset "detect_closure_boxes" begin
+    boxes = Test.detect_closure_boxes(ClosureBoxTest)
+    @test any(entry -> entry[1].name === :boxed, boxes)
+    @test any(entry -> entry[1].name === :boxed_sub, boxes)
+
+    sub_boxes = Test.detect_closure_boxes(ClosureBoxTest.Sub)
+    @test any(entry -> entry[1].name === :boxed_sub, sub_boxes)
+    @test all(entry -> parentmodule(entry[1]) === ClosureBoxTest.Sub, sub_boxes)
+
+    @test isempty(Test.detect_closure_boxes())
+end
+
 @testset "@test with skip/broken kwargs" begin
     # Make sure the local variables can be used in conditions
     a = 1