Package evaluation to test Counters on Julia 1.14.0-DEV.2373 (cf67ecc88f*) started at 2026-06-13T03:03:30.547 ################################################################################ # Set-up # Installing PkgEval dependencies (TestEnv)... Activating project at `~/.julia/environments/v1.14` Set-up completed after 15.53s ################################################################################ # Installation # Installing Counters... Resolving package versions... Installed Counters ─ v0.3.4 Updating `~/.julia/environments/v1.14/Project.toml` [5a653867] + Counters v0.3.4 Updating `~/.julia/environments/v1.14/Manifest.toml` [5a653867] + Counters v0.3.4 [56f22d72] + Artifacts v1.11.0 [8f399da3] + Libdl v1.11.0 [37e2e46d] + LinearAlgebra v1.14.0 [9a3f8284] + Random v1.11.0 [ea8e919c] + SHA v1.13.0 [9e88b42a] + Serialization v1.11.0 [2f01184e] + SparseArrays v1.13.0 [e66e0078] + CompilerSupportLibraries_jll v1.5.2+0 [4536629a] + OpenBLAS_jll v0.3.33+0 [bea87d4a] + SuiteSparse_jll v7.10.1+0 [8e850b90] + libblastrampoline_jll v5.15.0+0 Installation completed after 1.69s ################################################################################ # Precompilation # Precompiling PkgEval dependencies... Precompiling project... 6.5 s ✓ TestEnv 1 dependency successfully precompiled in 7 seconds. 27 already precompiled. Precompiling package dependencies... Precompiling project... ┌ Info: JuliaLowering threw given input: │ code = │ :(#= /home/pkgeval/.julia/packages/Counters/iCdr8/src/Counters.jl:209 =# Core.@doc " collect_by_counts(C::Counter)\n\nReturn a list of the elements counted by `C` in which the element\nwith the highest count is first, the element with the second highest \ncount is second, and so forth. Elements whose count is zero are excluded.\n" function collect_by_counts(C::Counter{T}) where T │ #= /home/pkgeval/.julia/packages/Counters/iCdr8/src/Counters.jl:216 =# │ #= /home/pkgeval/.julia/packages/Counters/iCdr8/src/Counters.jl:217 =# │ clean!(C) │ #= /home/pkgeval/.julia/packages/Counters/iCdr8/src/Counters.jl:218 =# │ lt(a::Pair{T, Int}, b::Pair{T, Int})::Bool = begin │ #= /home/pkgeval/.julia/packages/Counters/iCdr8/src/Counters.jl:218 =# │ a[2] >= b[2] │ end │ #= /home/pkgeval/.julia/packages/Counters/iCdr8/src/Counters.jl:219 =# │ pairs = collect(C.data) │ #= /home/pkgeval/.julia/packages/Counters/iCdr8/src/Counters.jl:220 =# │ sort!(pairs, lt = lt) │ #= /home/pkgeval/.julia/packages/Counters/iCdr8/src/Counters.jl:221 =# │ return [p[1] for p = pairs] │ end) │ st0 = │ SyntaxTree with attributes mod,kind,var_id,toplevel_pure,scope_type,macro_source,name_val,syntax_flags,meta,scope_layer,value,jl_source,is_toplevel_thunk,source,__macro_ctx__ │ [macrocall] │ │ @doc :: Identifier │ mod │ :(#= /home/pkgeval/.julia/packages/Counters/iCdr8/src/Counters.jl:209 =#) :: Value │ │ " collect_by_counts(C::Counter)\n\nReturn a list of the elements counted by `C` in which the element\nwith the highest count is first, the element with the second highest \ncount is second, and so forth. Elements whose count is zero are excluded.\n" :: Value │ │ [function] │ │ [where] │ │ [call] │ │ collect_by_counts :: Identifier │ │ [::] │ │ C :: Identifier │ │ [curly] │ │ Counter :: Identifier │ │ T :: Identifier │ │ T :: Identifier │ │ [block] │ │ [call] │ │ clean! :: Identifier │ │ C :: Identifier │ │ [=] │ │ [::] │ │ [call] │ │ lt :: Identifier │ │ [::] │ │ a :: Identifier │ │ [curly] │ │ Pair :: Identifier │ │ T :: Identifier │ │ Int :: Identifier │ │ [::] │ │ b :: Identifier │ │ [curly] │ │ Pair :: Identifier │ │ T :: Identifier │ │ Int :: Identifier │ │ Bool :: Identifier │ │ [block] │ │ [call] │ │ >= :: Identifier │ │ [ref] │ │ a :: Identifier │ │ 2 :: Value │ │ [ref] │ │ b :: Identifier │ │ 2 :: Value │ │ [=] │ │ pairs :: Identifier │ │ [call] │ │ collect :: Identifier │ │ [.] │ │ C :: Identifier │ │ [inert] │ │ data :: Identifier │ │ [call] │ │ sort! :: Identifier │ │ pairs :: Identifier │ │ [kw] │ │ lt :: Identifier │ │ lt :: Identifier │ │ [return] │ │ [comprehension] │ │ [generator] │ │ [ref] │ │ p :: Identifier │ │ 1 :: Value │ │ [=] │ │ p :: Identifier │ │ pairs :: Identifier │ │ │ st1 = │ SyntaxTree with attributes mod,kind,var_id,toplevel_pure,scope_type,macro_source,name_val,syntax_flags,meta,scope_layer,value,jl_source,is_toplevel_thunk,source │ [block] │ │ [=] │ │ val :: Identifier │ scope_layer=3 │ [function] │ │ [where] │ │ [call] │ │ collect_by_counts :: Identifier │ scope_layer=1 │ [::] │ │ C :: Identifier │ scope_layer=1 │ [curly] │ │ Counter :: Identifier │ scope_layer=1 │ T :: Identifier │ scope_layer=1 │ T :: Identifier │ scope_layer=1 │ [block] │ │ [call] │ │ clean! :: Identifier │ scope_layer=1 │ C :: Identifier │ scope_layer=1 │ [=] │ │ [::] │ │ [call] │ │ lt :: Identifier │ scope_layer=1 │ [::] │ │ a :: Identifier │ scope_layer=1 │ [curly] │ │ Pair :: Identifier │ scope_layer=1 │ T :: Identifier │ scope_layer=1 │ Int :: Identifier │ scope_layer=1 │ [::] │ │ b :: Identifier │ scope_layer=1 │ [curly] │ │ Pair :: Identifier │ scope_layer=1 │ T :: Identifier │ scope_layer=1 │ Int :: Identifier │ scope_layer=1 │ Bool :: Identifier │ scope_layer=1 │ [block] │ │ [call] │ │ >= :: Identifier │ scope_layer=1 │ [ref] │ │ a :: Identifier │ scope_layer=1 │ 2 :: Value │ macro_source=67 │ [ref] │ │ b :: Identifier │ scope_layer=1 │ 2 :: Value │ macro_source=67 │ [=] │ │ pairs :: Identifier │ scope_layer=1 │ [call] │ │ collect :: Identifier │ scope_layer=1 │ [.] │ │ C :: Identifier │ scope_layer=1 │ [inert] │ │ data :: Identifier │ │ [call] │ │ sort! :: Identifier │ scope_layer=1 │ pairs :: Identifier │ scope_layer=1 │ [kw] │ │ lt :: Identifier │ scope_layer=1 │ lt :: Identifier │ scope_layer=1 │ [return] │ │ [comprehension] │ │ [generator] │ │ [ref] │ │ p :: Identifier │ scope_layer=1 │ 1 :: Value │ macro_source=67 │ [=] │ │ p :: Identifier │ scope_layer=1 │ pairs :: Identifier │ scope_layer=1 │ [call] │ │ Base.Docs.doc! :: Value │ macro_source=67 │ Counters :: Value │ macro_source=67 │ [call] │ │ Base.Docs.Binding :: Value │ macro_source=67 │ Counters :: Value │ │ [inert] │ jl_source=L65 │ collect_by_counts :: Identifier │ │ [call] │ macro_source=67 │ Base.Docs.docstr :: Value │ macro_source=67 │ [call] │ macro_source=67 │ Core.svec :: Value │ macro_source=67 │ " collect_by_counts(C::Counter)\n\nReturn a list of the elements counted by `C` in which the element\nwith the highest count is first, the element with the second highest \ncount is second, and so forth. Elements whose count is zero are excluded.\n" :: Value │ macro_source=67 │ [call] │ macro_source=67 │ Dict{Symbol, Any} :: Value │ macro_source=67 │ :path => "/home/pkgeval/.julia/packages/Counters/iCdr8/src/Counters.jl" :: Value │ macro_source=67 │ :linenumber => 209 :: Value │ macro_source=67 │ :module => Counters :: Value │ macro_source=67 │ [where] │ │ [curly] │ │ Union :: Identifier │ scope_layer=1 │ [curly] │ │ Tuple :: Identifier │ scope_layer=1 │ [curly] │ │ Counter :: Identifier │ scope_layer=1 │ T :: Identifier │ scope_layer=1 │ [curly] │ │ Tuple :: Identifier │ scope_layer=1 │ T :: Identifier │ scope_layer=1 │ [<:] │ scope_layer=1 │ T :: Identifier │ scope_layer=1 │ Any :: Identifier │ scope_layer=1 │ val :: Identifier │ scope_layer=3 │ │ file = "/home/pkgeval/.julia/packages/Counters/iCdr8/src/Counters.jl" │ line = 209 └ mod = Counters ERROR: LoadError: LoweringError: #= /home/pkgeval/.julia/packages/Counters/iCdr8/src/Counters.jl:218 =# - Found unexpected binding of kind static_parameter Expression:  #₁₄/T Containing expressions:  (= #₄₄/T #₁₄/T)  (call core.svec (call core.svec #₃₄/#collect_by_counts#lt##0 (call core.apply_type #₁₉/Pair #₁₄/T #₂₀/Int) (call core.apply_type #₁₉/Pair #₁₄/T #₂₀/Int)) (call core.svec) SourceLocation:/home/pkgeval/.julia/packages/Counters/iCdr8/src/Counters.jl:218:0)  (call core.svec (call core.svec (function_type #₁₆/lt) (call core.apply_type #₁₉/Pair #₁₄/T #₂₀/Int) (call core.apply_type #₁₉/Pair #₁₄/T #₂₀/Int)) (call core.svec) SourceLocation:/home/pkgeval/.julia/packages/Counters/iCdr8/src/Counters.jl:218:0)  Detailed provenance:  #₁₄/T  └─ T  └─ T  ├─ @ /home/pkgeval/.julia/packages/Counters/iCdr8/src/Counters.jl:218  └─ (macrocall @doc :(#= /home/pkgeval/.julia/packages/Counters/iCdr8/src/Counters.jl:209 =#) " collect_by_counts(C::Counter)\n\nReturn a list of the elements counted by `C` in which the element\nwith the highest count is first, the element with the second highest \ncount is second, and so forth. Elements whose count is zero are excluded.\n" (function (where (call collect_by_counts (:: C (curly Counter T))) T) (block (call clean! C) (= (:: (call lt (:: a (curly Pair T Int)) (:: b (curly Pair T Int))) Bool) (block (call >= (ref a 2) (ref b 2)))) (= pairs (call collect (. C (inert data)))) (call sort! pairs (kw lt lt)) (return (comprehension (generator (ref p 1) (= p pairs)))))))  └─ @ /home/pkgeval/.julia/packages/Counters/iCdr8/src/Counters.jl:209  Stacktrace:  [1] _renumber(ctx::Base.JuliaLowering.LinearIRContext{Dict{Symbol, Dict{Int64, Any}}}, ssa_rewrites::Dict{Int64, Int64}, slot_rewrites::Dict{Int64, Int64}, label_table::Dict{Int64, Int64}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}})  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/linear_ir.jl:1097  [2] renumber_body(ctx::Base.JuliaLowering.LinearIRContext{Dict{Symbol, Dict{Int64, Any}}}, input_code::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, Vector{Int64}}, slot_rewrites::Dict{Int64, Int64})  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/linear_ir.jl:1162  [3] compile_lambda(outer_ctx::Base.JuliaLowering.LinearIRContext{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}})  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/linear_ir.jl:1257  [4] linearize_ir(ctx::Base.JuliaLowering.ClosureConversionCtx{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}})  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/linear_ir.jl:1287  [5] core_lowering_hook(code::Any, mod::Module, file::String, line::UInt64, world::UInt64, _warn::Bool)  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/hooks.jl:33  [6] include(mod::Module, _path::String)  @ Base Base.jl:325  [7] include_package_for_output(pkg::Base.PkgId, input::String, syntax_version::VersionNumber, depot_path::Vector{String}, dl_load_path::Vector{String}, load_path::Vector{String}, concrete_deps::Vector{Pair{Base.PkgId, UInt128}}, source::Nothing)  @ Base loading.jl:3296  [8] top-level scope  @ stdin:5  [9] eval(m::Module, e::Any)  @ Core boot.jl:522  [10] include_string(mapexpr::typeof(identity), mod::Module, code::String, filename::String)  @ Base loading.jl:3132  [11] include_string(m::Module, txt::String, fname::String)  @ Base loading.jl:3142 [inlined]  [12] exec_options(opts::Base.JLOptions)  @ Base client.jl:353  [13] _start()  @ Base client.jl:596 in expression starting at /home/pkgeval/.julia/packages/Counters/iCdr8/src/Counters.jl:1 in expression starting at stdin:5 ✗ Counters Precompilation completed after 71.29s ################################################################################ # Testing # Testing Counters Status `/tmp/jl_3NV7SP/Project.toml` [5a653867] Counters v0.3.4 [2f01184e] SparseArrays v1.13.0 [8dfed614] Test v1.11.0 Status `/tmp/jl_3NV7SP/Manifest.toml` [5a653867] Counters v0.3.4 [56f22d72] Artifacts v1.11.0 [2a0f44e3] Base64 v1.11.0 [b77e0a4c] InteractiveUtils v1.11.0 [ac6e5ff7] JuliaSyntaxHighlighting v1.13.0 [8f399da3] Libdl v1.11.0 [37e2e46d] LinearAlgebra v1.14.0 [56ddb016] Logging v1.11.0 [d6f4376e] Markdown v1.11.0 [9a3f8284] Random v1.11.0 [ea8e919c] SHA v1.13.0 [9e88b42a] Serialization v1.11.0 [2f01184e] SparseArrays v1.13.0 [f489334b] StyledStrings v1.13.0 [8dfed614] Test v1.11.0 [e66e0078] CompilerSupportLibraries_jll v1.5.2+0 [4536629a] OpenBLAS_jll v0.3.33+0 [bea87d4a] SuiteSparse_jll v7.10.1+0 [8e850b90] libblastrampoline_jll v5.15.0+0 Testing Running tests... ┌ Info: JuliaLowering threw given input: │ code = │ :(#= /home/pkgeval/.julia/packages/Counters/iCdr8/src/Counters.jl:209 =# Core.@doc " collect_by_counts(C::Counter)\n\nReturn a list of the elements counted by `C` in which the element\nwith the highest count is first, the element with the second highest \ncount is second, and so forth. Elements whose count is zero are excluded.\n" function collect_by_counts(C::Counter{T}) where T │ #= /home/pkgeval/.julia/packages/Counters/iCdr8/src/Counters.jl:216 =# │ #= /home/pkgeval/.julia/packages/Counters/iCdr8/src/Counters.jl:217 =# │ clean!(C) │ #= /home/pkgeval/.julia/packages/Counters/iCdr8/src/Counters.jl:218 =# │ lt(a::Pair{T, Int}, b::Pair{T, Int})::Bool = begin │ #= /home/pkgeval/.julia/packages/Counters/iCdr8/src/Counters.jl:218 =# │ a[2] >= b[2] │ end │ #= /home/pkgeval/.julia/packages/Counters/iCdr8/src/Counters.jl:219 =# │ pairs = collect(C.data) │ #= /home/pkgeval/.julia/packages/Counters/iCdr8/src/Counters.jl:220 =# │ sort!(pairs, lt = lt) │ #= /home/pkgeval/.julia/packages/Counters/iCdr8/src/Counters.jl:221 =# │ return [p[1] for p = pairs] │ end) │ st0 = │ SyntaxTree with attributes mod,kind,var_id,toplevel_pure,scope_type,macro_source,name_val,syntax_flags,meta,scope_layer,value,jl_source,is_toplevel_thunk,source,__macro_ctx__ │ [macrocall] │ │ @doc :: Identifier │ mod │ :(#= /home/pkgeval/.julia/packages/Counters/iCdr8/src/Counters.jl:209 =#) :: Value │ │ " collect_by_counts(C::Counter)\n\nReturn a list of the elements counted by `C` in which the element\nwith the highest count is first, the element with the second highest \ncount is second, and so forth. Elements whose count is zero are excluded.\n" :: Value │ │ [function] │ │ [where] │ │ [call] │ │ collect_by_counts :: Identifier │ │ [::] │ │ C :: Identifier │ │ [curly] │ │ Counter :: Identifier │ │ T :: Identifier │ │ T :: Identifier │ │ [block] │ │ [call] │ │ clean! :: Identifier │ │ C :: Identifier │ │ [=] │ │ [::] │ │ [call] │ │ lt :: Identifier │ │ [::] │ │ a :: Identifier │ │ [curly] │ │ Pair :: Identifier │ │ T :: Identifier │ │ Int :: Identifier │ │ [::] │ │ b :: Identifier │ │ [curly] │ │ Pair :: Identifier │ │ T :: Identifier │ │ Int :: Identifier │ │ Bool :: Identifier │ │ [block] │ │ [call] │ │ >= :: Identifier │ │ [ref] │ │ a :: Identifier │ │ 2 :: Value │ │ [ref] │ │ b :: Identifier │ │ 2 :: Value │ │ [=] │ │ pairs :: Identifier │ │ [call] │ │ collect :: Identifier │ │ [.] │ │ C :: Identifier │ │ [inert] │ │ data :: Identifier │ │ [call] │ │ sort! :: Identifier │ │ pairs :: Identifier │ │ [kw] │ │ lt :: Identifier │ │ lt :: Identifier │ │ [return] │ │ [comprehension] │ │ [generator] │ │ [ref] │ │ p :: Identifier │ │ 1 :: Value │ │ [=] │ │ p :: Identifier │ │ pairs :: Identifier │ │ │ st1 = │ SyntaxTree with attributes mod,kind,var_id,toplevel_pure,scope_type,macro_source,name_val,syntax_flags,meta,scope_layer,value,jl_source,is_toplevel_thunk,source │ [block] │ │ [=] │ │ val :: Identifier │ scope_layer=3 │ [function] │ │ [where] │ │ [call] │ │ collect_by_counts :: Identifier │ scope_layer=1 │ [::] │ │ C :: Identifier │ scope_layer=1 │ [curly] │ │ Counter :: Identifier │ scope_layer=1 │ T :: Identifier │ scope_layer=1 │ T :: Identifier │ scope_layer=1 │ [block] │ │ [call] │ │ clean! :: Identifier │ scope_layer=1 │ C :: Identifier │ scope_layer=1 │ [=] │ │ [::] │ │ [call] │ │ lt :: Identifier │ scope_layer=1 │ [::] │ │ a :: Identifier │ scope_layer=1 │ [curly] │ │ Pair :: Identifier │ scope_layer=1 │ T :: Identifier │ scope_layer=1 │ Int :: Identifier │ scope_layer=1 │ [::] │ │ b :: Identifier │ scope_layer=1 │ [curly] │ │ Pair :: Identifier │ scope_layer=1 │ T :: Identifier │ scope_layer=1 │ Int :: Identifier │ scope_layer=1 │ Bool :: Identifier │ scope_layer=1 │ [block] │ │ [call] │ │ >= :: Identifier │ scope_layer=1 │ [ref] │ │ a :: Identifier │ scope_layer=1 │ 2 :: Value │ macro_source=67 │ [ref] │ │ b :: Identifier │ scope_layer=1 │ 2 :: Value │ macro_source=67 │ [=] │ │ pairs :: Identifier │ scope_layer=1 │ [call] │ │ collect :: Identifier │ scope_layer=1 │ [.] │ │ C :: Identifier │ scope_layer=1 │ [inert] │ │ data :: Identifier │ │ [call] │ │ sort! :: Identifier │ scope_layer=1 │ pairs :: Identifier │ scope_layer=1 │ [kw] │ │ lt :: Identifier │ scope_layer=1 │ lt :: Identifier │ scope_layer=1 │ [return] │ │ [comprehension] │ │ [generator] │ │ [ref] │ │ p :: Identifier │ scope_layer=1 │ 1 :: Value │ macro_source=67 │ [=] │ │ p :: Identifier │ scope_layer=1 │ pairs :: Identifier │ scope_layer=1 │ [call] │ │ Base.Docs.doc! :: Value │ macro_source=67 │ Counters :: Value │ macro_source=67 │ [call] │ │ Base.Docs.Binding :: Value │ macro_source=67 │ Counters :: Value │ │ [inert] │ jl_source=L65 │ collect_by_counts :: Identifier │ │ [call] │ macro_source=67 │ Base.Docs.docstr :: Value │ macro_source=67 │ [call] │ macro_source=67 │ Core.svec :: Value │ macro_source=67 │ " collect_by_counts(C::Counter)\n\nReturn a list of the elements counted by `C` in which the element\nwith the highest count is first, the element with the second highest \ncount is second, and so forth. Elements whose count is zero are excluded.\n" :: Value │ macro_source=67 │ [call] │ macro_source=67 │ Dict{Symbol, Any} :: Value │ macro_source=67 │ :path => "/home/pkgeval/.julia/packages/Counters/iCdr8/src/Counters.jl" :: Value │ macro_source=67 │ :linenumber => 209 :: Value │ macro_source=67 │ :module => Counters :: Value │ macro_source=67 │ [where] │ │ [curly] │ │ Union :: Identifier │ scope_layer=1 │ [curly] │ │ Tuple :: Identifier │ scope_layer=1 │ [curly] │ │ Counter :: Identifier │ scope_layer=1 │ T :: Identifier │ scope_layer=1 │ [curly] │ │ Tuple :: Identifier │ scope_layer=1 │ T :: Identifier │ scope_layer=1 │ [<:] │ scope_layer=1 │ T :: Identifier │ scope_layer=1 │ Any :: Identifier │ scope_layer=1 │ val :: Identifier │ scope_layer=3 │ │ file = "/home/pkgeval/.julia/packages/Counters/iCdr8/src/Counters.jl" │ line = 209 └ mod = Counters ERROR: LoadError: LoweringError: #= /home/pkgeval/.julia/packages/Counters/iCdr8/src/Counters.jl:218 =# - Found unexpected binding of kind static_parameter Expression:  #₁₄/T Containing expressions:  (= #₄₄/T #₁₄/T)  (call core.svec (call core.svec #₃₄/#collect_by_counts#lt##0 (call core.apply_type #₁₉/Pair #₁₄/T #₂₀/Int) (call core.apply_type #₁₉/Pair #₁₄/T #₂₀/Int)) (call core.svec) SourceLocation:/home/pkgeval/.julia/packages/Counters/iCdr8/src/Counters.jl:218:0)  (call core.svec (call core.svec (function_type #₁₆/lt) (call core.apply_type #₁₉/Pair #₁₄/T #₂₀/Int) (call core.apply_type #₁₉/Pair #₁₄/T #₂₀/Int)) (call core.svec) SourceLocation:/home/pkgeval/.julia/packages/Counters/iCdr8/src/Counters.jl:218:0)  Detailed provenance:  #₁₄/T  └─ T  └─ T  ├─ @ /home/pkgeval/.julia/packages/Counters/iCdr8/src/Counters.jl:218  └─ (macrocall @doc :(#= /home/pkgeval/.julia/packages/Counters/iCdr8/src/Counters.jl:209 =#) " collect_by_counts(C::Counter)\n\nReturn a list of the elements counted by `C` in which the element\nwith the highest count is first, the element with the second highest \ncount is second, and so forth. Elements whose count is zero are excluded.\n" (function (where (call collect_by_counts (:: C (curly Counter T))) T) (block (call clean! C) (= (:: (call lt (:: a (curly Pair T Int)) (:: b (curly Pair T Int))) Bool) (block (call >= (ref a 2) (ref b 2)))) (= pairs (call collect (. C (inert data)))) (call sort! pairs (kw lt lt)) (return (comprehension (generator (ref p 1) (= p pairs)))))))  └─ @ /home/pkgeval/.julia/packages/Counters/iCdr8/src/Counters.jl:209  Stacktrace:  [1] _renumber(ctx::Base.JuliaLowering.LinearIRContext{Dict{Symbol, Dict{Int64, Any}}}, ssa_rewrites::Dict{Int64, Int64}, slot_rewrites::Dict{Int64, Int64}, label_table::Dict{Int64, Int64}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}})  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/linear_ir.jl:1097  [2] renumber_body(ctx::Base.JuliaLowering.LinearIRContext{Dict{Symbol, Dict{Int64, Any}}}, input_code::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, Vector{Int64}}, slot_rewrites::Dict{Int64, Int64})  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/linear_ir.jl:1162  [3] compile_lambda(outer_ctx::Base.JuliaLowering.LinearIRContext{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}})  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/linear_ir.jl:1257  [4] linearize_ir(ctx::Base.JuliaLowering.ClosureConversionCtx{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}})  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/linear_ir.jl:1287  [5] core_lowering_hook(code::Any, mod::Module, file::String, line::UInt64, world::UInt64, _warn::Bool)  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/hooks.jl:33  [6] include(mod::Module, _path::String)  @ Base Base.jl:325  [7] include_package_for_output(pkg::Base.PkgId, input::String, syntax_version::VersionNumber, depot_path::Vector{String}, dl_load_path::Vector{String}, load_path::Vector{String}, concrete_deps::Vector{Pair{Base.PkgId, UInt128}}, source::Nothing)  @ Base loading.jl:3296  [8] top-level scope  @ stdin:5  [9] eval(m::Module, e::Any)  @ Core boot.jl:522  [10] include_string(mapexpr::typeof(identity), mod::Module, code::String, filename::String)  @ Base loading.jl:3132  [11] include_string(m::Module, txt::String, fname::String)  @ Base loading.jl:3142 [inlined]  [12] exec_options(opts::Base.JLOptions)  @ Base client.jl:353  [13] _start()  @ Base client.jl:596 in expression starting at /home/pkgeval/.julia/packages/Counters/iCdr8/src/Counters.jl:1 in expression starting at stdin:5 1 dependency had output during precompilation: ┌ Counters │ [Output was shown above] └ ERROR: LoadError: The following 1 package failed to precompile: Counters Failed to precompile Counters [5a653867-b65e-5b16-a095-b1e26d522bbf] to "/home/pkgeval/.julia/compiled/v1.14/Counters/jl_wYW9PZ" (ProcessExited(1)). in expression starting at /home/pkgeval/.julia/packages/Counters/iCdr8/test/runtests.jl:1 Testing failed after 52.9s ERROR: LoadError: Package Counters errored during testing Stacktrace: [1] pkgerror(msg::String) @ Pkg.Types /opt/julia/share/julia/stdlib/v1.14/Pkg/src/Types.jl:68 [2] test(ctx::Pkg.Types.Context, pkgs::Vector{PackageSpec}; coverage::Bool, julia_args::Cmd, test_args::Cmd, test_fn::Nothing, force_latest_compatible_version::Bool, allow_earlier_backwards_compatible_versions::Bool, allow_reresolve::Bool) @ Pkg.Operations /opt/julia/share/julia/stdlib/v1.14/Pkg/src/Operations.jl:3247 [3] test(ctx::Pkg.Types.Context, pkgs::Vector{PackageSpec}; coverage::Bool, test_fn::Nothing, julia_args::Cmd, test_args::Cmd, force_latest_compatible_version::Bool, allow_earlier_backwards_compatible_versions::Bool, allow_reresolve::Bool, kwargs::@Kwargs{io::IOContext{IO}}) @ Pkg.API /opt/julia/share/julia/stdlib/v1.14/Pkg/src/API.jl:587 [4] test(pkgs::Vector{PackageSpec}; io::IOContext{IO}, kwargs::@Kwargs{julia_args::Cmd}) @ Pkg.API /opt/julia/share/julia/stdlib/v1.14/Pkg/src/API.jl:172 [5] test(pkgs::Vector{String}; kwargs::@Kwargs{julia_args::Cmd}) @ Pkg.API /opt/julia/share/julia/stdlib/v1.14/Pkg/src/API.jl:160 [6] test(pkg::String; kwargs::@Kwargs{julia_args::Cmd}) @ Pkg.API /opt/julia/share/julia/stdlib/v1.14/Pkg/src/API.jl:159 [inlined] [7] top-level scope @ /PkgEval.jl/scripts/evaluate.jl:223 [8] include(mod::Module, _path::String) @ Base Base.jl:325 [9] exec_options(opts::Base.JLOptions) @ Base client.jl:355 [10] _start() @ Base client.jl:596 in expression starting at /PkgEval.jl/scripts/evaluate.jl:214 PkgEval failed after 159.0s: package fails to precompile