Package evaluation of SparsityDetection on Julia 1.11.4 (a71dd056e0*) started at 2025-04-08T09:43:02.922 ################################################################################ # Set-up # Installing PkgEval dependencies (TestEnv)... Set-up completed after 8.71s ################################################################################ # Installation # Installing SparsityDetection... Resolving package versions... Updating `~/.julia/environments/v1.11/Project.toml` [684fba80] + SparsityDetection v0.3.4 Updating `~/.julia/environments/v1.11/Manifest.toml` [7057c7e9] + Cassette v0.3.14 [d360d2e6] + ChainRulesCore v1.25.1 [34da2185] + Compat v4.16.0 ⌅ [ffbed154] + DocStringExtensions v0.8.6 ⌅ [92d709cd] + IrrationalConstants v0.1.1 [692b3bcd] + JLLWrappers v1.7.0 [2ab3a3ac] + LogExpFunctions v0.3.29 [21216c6a] + Preferences v1.4.3 [684fba80] + SparsityDetection v0.3.4 ⌅ [276daf66] + SpecialFunctions v1.8.8 [efe28fd5] + OpenSpecFun_jll v0.5.6+0 [56f22d72] + Artifacts v1.11.0 [2a0f44e3] + Base64 v1.11.0 [ade2ca70] + Dates v1.11.0 [76f85450] + LibGit2 v1.11.0 [8f399da3] + Libdl v1.11.0 [37e2e46d] + LinearAlgebra v1.11.0 [ca575930] + NetworkOptions v1.2.0 [de0858da] + Printf v1.11.0 [9a3f8284] + Random v1.11.0 [ea8e919c] + SHA v0.7.0 [9e88b42a] + Serialization v1.11.0 [2f01184e] + SparseArrays v1.11.0 [fa267f1f] + TOML v1.0.3 [cf7118a7] + UUIDs v1.11.0 [4ec0a83e] + Unicode v1.11.0 [e66e0078] + CompilerSupportLibraries_jll v1.1.1+0 [e37daf67] + LibGit2_jll v1.7.2+0 [29816b5a] + LibSSH2_jll v1.11.0+1 [c8ffd9c3] + MbedTLS_jll v2.28.6+0 [4536629a] + OpenBLAS_jll v0.3.27+1 [05823500] + OpenLibm_jll v0.8.5+0 [bea87d4a] + SuiteSparse_jll v7.7.0+0 [8e850b90] + libblastrampoline_jll v5.11.0+0 Info Packages marked with ⌅ have new versions available but compatibility constraints restrict them from upgrading. To see why use `status --outdated -m` Installation completed after 1.96s ################################################################################ # Precompilation # Precompiling PkgEval dependencies... Precompiling package dependencies... Precompilation completed after 32.29s ################################################################################ # Testing # Testing SparsityDetection Status `/tmp/jl_f2bxHN/Project.toml` [7057c7e9] Cassette v0.3.14 ⌅ [ffbed154] DocStringExtensions v0.8.6 [6a86dc24] FiniteDiff v2.27.0 [1bc83da4] SafeTestsets v0.1.0 [684fba80] SparsityDetection v0.3.4 ⌅ [276daf66] SpecialFunctions v1.8.8 [37e2e46d] LinearAlgebra v1.11.0 [2f01184e] SparseArrays v1.11.0 [8dfed614] Test v1.11.0 Status `/tmp/jl_f2bxHN/Manifest.toml` [79e6a3ab] Adapt v4.3.0 [4fba245c] ArrayInterface v7.18.0 [7057c7e9] Cassette v0.3.14 [d360d2e6] ChainRulesCore v1.25.1 [34da2185] Compat v4.16.0 [187b0558] ConstructionBase v1.5.8 ⌅ [ffbed154] DocStringExtensions v0.8.6 [6a86dc24] FiniteDiff v2.27.0 ⌅ [92d709cd] IrrationalConstants v0.1.1 [692b3bcd] JLLWrappers v1.7.0 [2ab3a3ac] LogExpFunctions v0.3.29 [1914dd2f] MacroTools v0.5.15 [21216c6a] Preferences v1.4.3 [ae029012] Requires v1.3.1 [1bc83da4] SafeTestsets v0.1.0 [efcf1570] Setfield v1.1.2 [684fba80] SparsityDetection v0.3.4 ⌅ [276daf66] SpecialFunctions v1.8.8 [1e83bf80] StaticArraysCore v1.4.3 [efe28fd5] OpenSpecFun_jll v0.5.6+0 [56f22d72] Artifacts v1.11.0 [2a0f44e3] Base64 v1.11.0 [ade2ca70] Dates v1.11.0 [9fa8497b] Future v1.11.0 [b77e0a4c] InteractiveUtils v1.11.0 [76f85450] LibGit2 v1.11.0 [8f399da3] Libdl v1.11.0 [37e2e46d] LinearAlgebra v1.11.0 [56ddb016] Logging v1.11.0 [d6f4376e] Markdown v1.11.0 [ca575930] NetworkOptions v1.2.0 [de0858da] Printf v1.11.0 [9a3f8284] Random v1.11.0 [ea8e919c] SHA v0.7.0 [9e88b42a] Serialization v1.11.0 [2f01184e] SparseArrays v1.11.0 [fa267f1f] TOML v1.0.3 [8dfed614] Test v1.11.0 [cf7118a7] UUIDs v1.11.0 [4ec0a83e] Unicode v1.11.0 [e66e0078] CompilerSupportLibraries_jll v1.1.1+0 [e37daf67] LibGit2_jll v1.7.2+0 [29816b5a] LibSSH2_jll v1.11.0+1 [c8ffd9c3] MbedTLS_jll v2.28.6+0 [4536629a] OpenBLAS_jll v0.3.27+1 [05823500] OpenLibm_jll v0.8.5+0 [bea87d4a] SuiteSparse_jll v7.7.0+0 [8e850b90] libblastrampoline_jll v5.11.0+0 Info Packages marked with ⌅ have new versions available but compatibility constraints restrict them from upgrading. Testing Running tests... Explored path: SparsityDetection.Path(Bool[], 1) Explored path: SparsityDetection.Path(Bool[], 1) Explored path: SparsityDetection.Path(Bool[], 1) Explored path: SparsityDetection.Path(Bool[], 1) Explored path: SparsityDetection.Path(Bool[], 1) Jacobian Sparsity: Error During Test at /home/pkgeval/.julia/packages/SparsityDetection/E7o7R/test/jacobian.jl:14 Test threw exception Expression: jactestval(((Y, X)->begin #= /home/pkgeval/.julia/packages/SparsityDetection/E7o7R/test/jacobian.jl:14 =# (broadcasted(+, X, 1))[1] end), [1], [2]) == 3 MethodError: no method matching load(::Tuple{Int64}) The function `load` exists, but no method is defined for this combination of argument types. Closest candidates are: load(!Matched::Cassette.Immutable) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/tagging.jl:25 load(!Matched::Cassette.Mutable) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/tagging.jl:15 Stacktrace: [1] tagged_getfield @ ~/.julia/packages/Cassette/ROd5e/src/tagging.jl:629 [inlined] [2] tagged_getfield @ ~/.julia/packages/Cassette/ROd5e/src/tagging.jl:617 [inlined] [3] overdub @ ~/.julia/packages/Cassette/ROd5e/src/context.jl:287 [inlined] [4] size(::Vector{Int64}) @ ./array.jl:194 [inlined] [5] size @ ./array.jl:194 [inlined] [6] recurse(::ctx, ::typeof(size), ::tagged{Vector{Int64}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [7] overdub(ctx::ctx, f::Function, args::tagged{Vector{Int64}}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:45 [8] axes @ ./abstractarray.jl:98 [inlined] [9] recurse(::ctx, ::typeof(axes), ::tagged{Vector{Int64}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [10] overdub(ctx::ctx, f::Function, args::tagged{Vector{Int64}}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:45 [11] combine_axes(::Vector{Int64}, ::Int64) @ ./broadcast.jl:497 [inlined] [12] combine_axes @ ./broadcast.jl:497 [inlined] [13] recurse(::ctx, ::typeof(Base.Broadcast.combine_axes), ::tagged{Vector{Int64}}, ::tagged{Int64}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [14] overdub(::ctx, ::Function, ::tagged{Vector{Int64}}, ::tagged{Int64}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:45 [15] overdub(ctx::ctx, ::typeof(Core._apply_iterate), iter::Function, f::Function, args::tagged{Tuple{Vector{Int64}, Int64}}) @ SparsityDetection ~/.julia/packages/Cassette/ROd5e/src/context.jl:264 [16] _axes(::Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(+), Tuple{Vector{Int64}, Int64}}, ::Nothing) @ ./broadcast.jl:236 [inlined] [17] _axes @ ./broadcast.jl:236 [inlined] [18] recurse(::ctx, ::typeof(Base.Broadcast._axes), ::tagged{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(+), Tuple{Vector{Int64}, Int64}}}, ::tagged{Nothing}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [19] overdub(::ctx, ::Function, ::tagged{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(+), Tuple{Vector{Int64}, Int64}}}, ::tagged{Nothing}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:37 [20] axes(::Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(+), Tuple{Vector{Int64}, Int64}}) @ ./broadcast.jl:234 [inlined] [21] axes @ ./broadcast.jl:234 [inlined] [22] recurse(::ctx, ::typeof(axes), ::tagged{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(+), Tuple{Vector{Int64}, Int64}}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [23] overdub(ctx::ctx, f::Function, args::tagged{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(+), Tuple{Vector{Int64}, Int64}}}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:37 [24] checkbounds(::Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(+), Tuple{Vector{Int64}, Int64}}, ::Int64) @ ./broadcast.jl:616 [inlined] [25] checkbounds @ ./broadcast.jl:616 [inlined] [26] recurse(::ctx, ::typeof(checkbounds), ::tagged{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(+), Tuple{Vector{Int64}, Int64}}}, ::Int64) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [27] overdub(::ctx, ::Function, ::tagged{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(+), Tuple{Vector{Int64}, Int64}}}, ::Int64) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:37 [28] getindex @ ./broadcast.jl:609 [inlined] [29] overdub(ctx::ctx, f::typeof(getindex), X::tagged{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(+), Tuple{Vector{Int64}, Int64}}}, idx::Int64) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/jacobian.jl:102 [30] (::var" @ ~/.julia/packages/SparsityDetection/E7o7R/test/jacobian.jl:14 [inlined] [31] #18 @ ~/.julia/packages/SparsityDetection/E7o7R/test/jacobian.jl:14 [inlined] [32] recurse(::ctx, ::var"#18#27", ::tagged{Vector{Int64}}, ::tagged{Vector{Int64}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [33] overdub(::ctx, ::Function, ::tagged{Vector{Int64}}, ::tagged{Vector{Int64}}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:45 [34] overdub @ ~/.julia/packages/Cassette/ROd5e/src/context.jl:264 [inlined] [35] (::SparsityDetection.var" @ ~/.julia/packages/SparsityDetection/E7o7R/src/controlflow.jl:148 [inlined] [36] #2 @ ~/.julia/packages/SparsityDetection/E7o7R/src/controlflow.jl:148 [inlined] [37] recurse(overdub_context#230::ctx, overdub_arguments#231::SparsityDetection.var"#2#3"{var"#18#27", Tuple{tagged{Vector{Int64}}, tagged{Vector{Int64}}}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [38] abstract_run(::SparsityDetection.var"#22#24", ::ctx, ::Function, ::tagged{Vector{Int64}}, ::Vararg{tagged{Vector{Int64}}}; verbose::Bool) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/controlflow.jl:148 [39] jacobian_sparsity(::Function, ::Vector{Int64}, ::Vector{Int64}; sparsity::Sparsity, verbose::Bool, raw::Bool) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/jacobian.jl:135 [40] jacobian_sparsity @ ~/.julia/packages/SparsityDetection/E7o7R/src/jacobian.jl:125 [inlined] [41] jactester(::Function, ::Vector{Int64}, ::Vector{Int64}) @ Main ~/.julia/packages/SparsityDetection/E7o7R/test/common.jl:14 [42] jactestval(::Function, ::Vararg{Any}) @ Main ~/.julia/packages/SparsityDetection/E7o7R/test/common.jl:18 [43] macro expansion @ /opt/julia/share/julia/stdlib/v1.11/Test/src/Test.jl:676 [inlined] [44] top-level scope @ ~/.julia/packages/SparsityDetection/E7o7R/test/jacobian.jl:14 Jacobian Sparsity: Error During Test at /home/pkgeval/.julia/packages/SparsityDetection/E7o7R/test/jacobian.jl:15 Test threw exception Expression: jactestval(f, [1], [2]) == [3] MethodError: no method matching load(::Tuple{Int64}) The function `load` exists, but no method is defined for this combination of argument types. Closest candidates are: load(!Matched::Cassette.Immutable) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/tagging.jl:25 load(!Matched::Cassette.Mutable) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/tagging.jl:15 Stacktrace: [1] tagged_getfield @ ~/.julia/packages/Cassette/ROd5e/src/tagging.jl:629 [inlined] [2] tagged_getfield @ ~/.julia/packages/Cassette/ROd5e/src/tagging.jl:617 [inlined] [3] overdub @ ~/.julia/packages/Cassette/ROd5e/src/context.jl:287 [inlined] [4] size(::Vector{Int64}) @ ./array.jl:194 [inlined] [5] size @ ./array.jl:194 [inlined] [6] recurse(::ctx, ::typeof(size), ::tagged{Vector{Int64}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [7] overdub(ctx::ctx, f::Function, args::tagged{Vector{Int64}}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:45 [8] axes @ ./abstractarray.jl:98 [inlined] [9] recurse(::ctx, ::typeof(axes), ::tagged{Vector{Int64}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [10] overdub(ctx::ctx, f::Function, args::tagged{Vector{Int64}}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:45 [11] combine_axes(::Vector{Int64}, ::Int64) @ ./broadcast.jl:497 [inlined] [12] combine_axes @ ./broadcast.jl:497 [inlined] [13] recurse(::ctx, ::typeof(Base.Broadcast.combine_axes), ::tagged{Vector{Int64}}, ::tagged{Int64}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [14] overdub(::ctx, ::Function, ::tagged{Vector{Int64}}, ::tagged{Int64}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:45 [15] overdub(ctx::ctx, ::typeof(Core._apply_iterate), iter::Function, f::Function, args::tagged{Tuple{Vector{Int64}, Int64}}) @ SparsityDetection ~/.julia/packages/Cassette/ROd5e/src/context.jl:264 [16] instantiate @ ./broadcast.jl:307 [inlined] [17] recurse(::ctx, ::typeof(Base.Broadcast.instantiate), ::tagged{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(+), Tuple{Vector{Int64}, Int64}}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [18] overdub(ctx::ctx, f::Function, args::tagged{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(+), Tuple{Vector{Int64}, Int64}}}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:37 [19] materialize(::Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(+), Tuple{Vector{Int64}, Int64}}) @ ./broadcast.jl:872 [inlined] [20] materialize @ ./broadcast.jl:872 [inlined] [21] recurse(::ctx, ::typeof(Base.Broadcast.materialize), ::tagged{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(+), Tuple{Vector{Int64}, Int64}}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [22] overdub(ctx::ctx, f::Function, args::tagged{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(+), Tuple{Vector{Int64}, Int64}}}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:37 [23] (::var" @ ~/.julia/packages/SparsityDetection/E7o7R/test/jacobian.jl:12 [inlined] [24] f @ ~/.julia/packages/SparsityDetection/E7o7R/test/jacobian.jl:12 [inlined] [25] recurse(::ctx, ::var"#f#26", ::tagged{Vector{Int64}}, ::tagged{Vector{Int64}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [26] overdub(::ctx, ::Function, ::tagged{Vector{Int64}}, ::tagged{Vector{Int64}}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:45 [27] overdub @ ~/.julia/packages/Cassette/ROd5e/src/context.jl:264 [inlined] [28] (::SparsityDetection.var" @ ~/.julia/packages/SparsityDetection/E7o7R/src/controlflow.jl:148 [inlined] [29] #2 @ ~/.julia/packages/SparsityDetection/E7o7R/src/controlflow.jl:148 [inlined] [30] recurse(overdub_context#230::ctx, overdub_arguments#231::SparsityDetection.var"#2#3"{var"#f#26", Tuple{tagged{Vector{Int64}}, tagged{Vector{Int64}}}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [31] abstract_run(::SparsityDetection.var"#22#24", ::ctx, ::Function, ::tagged{Vector{Int64}}, ::Vararg{tagged{Vector{Int64}}}; verbose::Bool) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/controlflow.jl:148 [32] jacobian_sparsity(::Function, ::Vector{Int64}, ::Vector{Int64}; sparsity::Sparsity, verbose::Bool, raw::Bool) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/jacobian.jl:135 [33] jacobian_sparsity @ ~/.julia/packages/SparsityDetection/E7o7R/src/jacobian.jl:125 [inlined] [34] jactester(::Function, ::Vector{Int64}, ::Vector{Int64}) @ Main ~/.julia/packages/SparsityDetection/E7o7R/test/common.jl:14 [35] jactestval(::Function, ::Vararg{Any}) @ Main ~/.julia/packages/SparsityDetection/E7o7R/test/common.jl:18 [36] macro expansion @ /opt/julia/share/julia/stdlib/v1.11/Test/src/Test.jl:676 [inlined] [37] top-level scope @ ~/.julia/packages/SparsityDetection/E7o7R/test/jacobian.jl:15 Jacobian Sparsity: Error During Test at /home/pkgeval/.julia/packages/SparsityDetection/E7o7R/test/jacobian.jl:16 Test threw exception Expression: sparse(jactestmeta(f, [1], [2])) == sparse([], [], true, 1, 1) MethodError: no method matching load(::Tuple{Int64}) The function `load` exists, but no method is defined for this combination of argument types. Closest candidates are: load(!Matched::Cassette.Immutable) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/tagging.jl:25 load(!Matched::Cassette.Mutable) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/tagging.jl:15 Stacktrace: [1] tagged_getfield @ ~/.julia/packages/Cassette/ROd5e/src/tagging.jl:629 [inlined] [2] tagged_getfield @ ~/.julia/packages/Cassette/ROd5e/src/tagging.jl:617 [inlined] [3] overdub @ ~/.julia/packages/Cassette/ROd5e/src/context.jl:287 [inlined] [4] size(::Vector{Int64}) @ ./array.jl:194 [inlined] [5] size @ ./array.jl:194 [inlined] [6] recurse(::ctx, ::typeof(size), ::tagged{Vector{Int64}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [7] overdub(ctx::ctx, f::Function, args::tagged{Vector{Int64}}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:45 [8] axes @ ./abstractarray.jl:98 [inlined] [9] recurse(::ctx, ::typeof(axes), ::tagged{Vector{Int64}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [10] overdub(ctx::ctx, f::Function, args::tagged{Vector{Int64}}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:45 [11] combine_axes(::Vector{Int64}, ::Int64) @ ./broadcast.jl:497 [inlined] [12] combine_axes @ ./broadcast.jl:497 [inlined] [13] recurse(::ctx, ::typeof(Base.Broadcast.combine_axes), ::tagged{Vector{Int64}}, ::tagged{Int64}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [14] overdub(::ctx, ::Function, ::tagged{Vector{Int64}}, ::tagged{Int64}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:45 [15] overdub(ctx::ctx, ::typeof(Core._apply_iterate), iter::Function, f::Function, args::tagged{Tuple{Vector{Int64}, Int64}}) @ SparsityDetection ~/.julia/packages/Cassette/ROd5e/src/context.jl:264 [16] instantiate @ ./broadcast.jl:307 [inlined] [17] recurse(::ctx, ::typeof(Base.Broadcast.instantiate), ::tagged{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(+), Tuple{Vector{Int64}, Int64}}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [18] overdub(ctx::ctx, f::Function, args::tagged{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(+), Tuple{Vector{Int64}, Int64}}}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:37 [19] materialize(::Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(+), Tuple{Vector{Int64}, Int64}}) @ ./broadcast.jl:872 [inlined] [20] materialize @ ./broadcast.jl:872 [inlined] [21] recurse(::ctx, ::typeof(Base.Broadcast.materialize), ::tagged{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(+), Tuple{Vector{Int64}, Int64}}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [22] overdub(ctx::ctx, f::Function, args::tagged{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(+), Tuple{Vector{Int64}, Int64}}}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:37 [23] (::var" @ ~/.julia/packages/SparsityDetection/E7o7R/test/jacobian.jl:12 [inlined] [24] f @ ~/.julia/packages/SparsityDetection/E7o7R/test/jacobian.jl:12 [inlined] [25] recurse(::ctx, ::var"#f#26", ::tagged{Vector{Int64}}, ::tagged{Vector{Int64}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [26] overdub(::ctx, ::Function, ::tagged{Vector{Int64}}, ::tagged{Vector{Int64}}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:45 [27] overdub @ ~/.julia/packages/Cassette/ROd5e/src/context.jl:264 [inlined] [28] (::SparsityDetection.var" @ ~/.julia/packages/SparsityDetection/E7o7R/src/controlflow.jl:148 [inlined] [29] #2 @ ~/.julia/packages/SparsityDetection/E7o7R/src/controlflow.jl:148 [inlined] [30] recurse(overdub_context#230::ctx, overdub_arguments#231::SparsityDetection.var"#2#3"{var"#f#26", Tuple{tagged{Vector{Int64}}, tagged{Vector{Int64}}}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [31] abstract_run(::SparsityDetection.var"#22#24", ::ctx, ::Function, ::tagged{Vector{Int64}}, ::Vararg{tagged{Vector{Int64}}}; verbose::Bool) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/controlflow.jl:148 [32] jacobian_sparsity(::Function, ::Vector{Int64}, ::Vector{Int64}; sparsity::Sparsity, verbose::Bool, raw::Bool) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/jacobian.jl:135 [33] jacobian_sparsity @ ~/.julia/packages/SparsityDetection/E7o7R/src/jacobian.jl:125 [inlined] [34] jactester(::Function, ::Vector{Int64}, ::Vector{Int64}) @ Main ~/.julia/packages/SparsityDetection/E7o7R/test/common.jl:14 [35] jactestmeta(::Function, ::Vararg{Any}) @ Main ~/.julia/packages/SparsityDetection/E7o7R/test/common.jl:17 [36] macro expansion @ /opt/julia/share/julia/stdlib/v1.11/Test/src/Test.jl:676 [inlined] [37] top-level scope @ ~/.julia/packages/SparsityDetection/E7o7R/test/jacobian.jl:16 Broadcast timings y .= x Jacobian Sparsity: Error During Test at /home/pkgeval/.julia/packages/SparsityDetection/E7o7R/test/jacobian.jl:24 Test threw exception Expression: #= /home/pkgeval/.julia/packages/SparsityDetection/E7o7R/test/jacobian.jl:24 =# @time jacobian_sparsity(((y, x)->begin #= /home/pkgeval/.julia/packages/SparsityDetection/E7o7R/test/jacobian.jl:24 =# y .= x end), [1, 2, 3], [1, 2, 3]) == sparse([1, 2, 3], [1, 2, 3], true) MethodError: no method matching load(::Tuple{Int64}) The function `load` exists, but no method is defined for this combination of argument types. Closest candidates are: load(!Matched::Cassette.Immutable) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/tagging.jl:25 load(!Matched::Cassette.Mutable) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/tagging.jl:15 Stacktrace: [1] tagged_getfield @ ~/.julia/packages/Cassette/ROd5e/src/tagging.jl:629 [inlined] [2] tagged_getfield @ ~/.julia/packages/Cassette/ROd5e/src/tagging.jl:617 [inlined] [3] overdub @ ~/.julia/packages/Cassette/ROd5e/src/context.jl:287 [inlined] [4] size(::Vector{Int64}) @ ./array.jl:194 [inlined] [5] size @ ./array.jl:194 [inlined] [6] recurse(::ctx, ::typeof(size), ::tagged{Vector{Int64}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [7] overdub(ctx::ctx, f::Function, args::tagged{Vector{Int64}}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:45 [8] axes @ ./abstractarray.jl:98 [inlined] [9] recurse(::ctx, ::typeof(axes), ::tagged{Vector{Int64}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [10] overdub(ctx::ctx, f::Function, args::tagged{Vector{Int64}}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:45 [11] materialize!(::Base.Broadcast.DefaultArrayStyle{1}, ::Vector{Int64}, ::Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(identity), Tuple{Vector{Int64}}}) @ ./broadcast.jl:883 [inlined] [12] materialize! @ ./broadcast.jl:883 [inlined] [13] recurse(::ctx, ::typeof(Base.Broadcast.materialize!), ::Base.Broadcast.DefaultArrayStyle{1}, ::tagged{Vector{Int64}}, ::tagged{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(identity), Tuple{Vector{Int64}}}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [14] overdub(::ctx, ::Function, ::Base.Broadcast.DefaultArrayStyle{1}, ::tagged{Vector{Int64}}, ::tagged{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(identity), Tuple{Vector{Int64}}}}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:45 [15] materialize!(::Vector{Int64}, ::Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(identity), Tuple{Vector{Int64}}}) @ ./broadcast.jl:880 [inlined] [16] materialize! @ ./broadcast.jl:880 [inlined] [17] recurse(::ctx, ::typeof(Base.Broadcast.materialize!), ::tagged{Vector{Int64}}, ::tagged{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(identity), Tuple{Vector{Int64}}}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [18] overdub(::ctx, ::Function, ::tagged{Vector{Int64}}, ::tagged{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(identity), Tuple{Vector{Int64}}}}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:45 [19] (::var" @ ~/.julia/packages/SparsityDetection/E7o7R/test/jacobian.jl:24 [inlined] [20] #19 @ ~/.julia/packages/SparsityDetection/E7o7R/test/jacobian.jl:24 [inlined] [21] recurse(::ctx, ::var"#19#29", ::tagged{Vector{Int64}}, ::tagged{Vector{Int64}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [22] overdub(::ctx, ::Function, ::tagged{Vector{Int64}}, ::tagged{Vector{Int64}}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:45 [23] overdub @ ~/.julia/packages/Cassette/ROd5e/src/context.jl:264 [inlined] [24] (::SparsityDetection.var" @ ~/.julia/packages/SparsityDetection/E7o7R/src/controlflow.jl:148 [inlined] [25] #2 @ ~/.julia/packages/SparsityDetection/E7o7R/src/controlflow.jl:148 [inlined] [26] recurse(overdub_context#230::ctx, overdub_arguments#231::SparsityDetection.var"#2#3"{var"#19#29", Tuple{tagged{Vector{Int64}}, tagged{Vector{Int64}}}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [27] abstract_run(::SparsityDetection.var"#22#24", ::ctx, ::Function, ::tagged{Vector{Int64}}, ::Vararg{tagged{Vector{Int64}}}; verbose::Bool) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/controlflow.jl:148 [28] jacobian_sparsity(::Function, ::Vector{Int64}, ::Vector{Int64}; sparsity::Sparsity, verbose::Bool, raw::Bool) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/jacobian.jl:135 [29] jacobian_sparsity(::Function, ::Vector{Int64}, ::Vector{Int64}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/jacobian.jl:125 [30] macro expansion @ ./timing.jl:581 [inlined] [31] macro expansion @ ~/.julia/packages/SparsityDetection/E7o7R/test/jacobian.jl:24 [inlined] [32] macro expansion @ /opt/julia/share/julia/stdlib/v1.11/Test/src/Test.jl:676 [inlined] [33] top-level scope @ ~/.julia/packages/SparsityDetection/E7o7R/test/jacobian.jl:24 y[:] .= x .+ 1 Jacobian Sparsity: Error During Test at /home/pkgeval/.julia/packages/SparsityDetection/E7o7R/test/jacobian.jl:26 Test threw exception Expression: #= /home/pkgeval/.julia/packages/SparsityDetection/E7o7R/test/jacobian.jl:26 =# @time sparse(jactestmeta(g, [1], [2])) == sparse([1], [1], true) MethodError: no method matching load(::Tuple{Int64}) The function `load` exists, but no method is defined for this combination of argument types. Closest candidates are: load(!Matched::Cassette.Immutable) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/tagging.jl:25 load(!Matched::Cassette.Mutable) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/tagging.jl:15 Stacktrace: [1] tagged_getfield @ ~/.julia/packages/Cassette/ROd5e/src/tagging.jl:629 [inlined] [2] tagged_getfield @ ~/.julia/packages/Cassette/ROd5e/src/tagging.jl:617 [inlined] [3] overdub @ ~/.julia/packages/Cassette/ROd5e/src/context.jl:287 [inlined] [4] size(::Vector{Int64}) @ ./array.jl:194 [inlined] [5] size @ ./array.jl:194 [inlined] [6] recurse(::ctx, ::typeof(size), ::tagged{Vector{Int64}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [7] overdub(ctx::ctx, f::Function, args::tagged{Vector{Int64}}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:45 [8] axes @ ./abstractarray.jl:98 [inlined] [9] recurse(::ctx, ::typeof(axes), ::tagged{Vector{Int64}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [10] overdub(ctx::ctx, f::Function, args::tagged{Vector{Int64}}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:45 [11] axes1(::Vector{Int64}) @ ./abstractarray.jl:137 [inlined] [12] axes1 @ ./abstractarray.jl:137 [inlined] [13] recurse(::ctx, ::typeof(Base.axes1), ::tagged{Vector{Int64}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [14] overdub(ctx::ctx, f::Function, args::tagged{Vector{Int64}}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:45 [15] eachindex(::IndexLinear, ::Vector{Int64}) @ ./abstractarray.jl:389 [inlined] [16] eachindex @ ./abstractarray.jl:389 [inlined] [17] recurse(::ctx, ::typeof(eachindex), ::IndexLinear, ::tagged{Vector{Int64}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [18] overdub(::ctx, ::Function, ::IndexLinear, ::tagged{Vector{Int64}}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:45 [19] to_indices(::Vector{Int64}, ::Tuple{Colon}) @ ./indices.jl:360 [inlined] [20] to_indices @ ./indices.jl:360 [inlined] [21] recurse(::ctx, ::typeof(to_indices), ::tagged{Vector{Int64}}, ::tagged{Tuple{Colon}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [22] overdub(::ctx, ::Function, ::tagged{Vector{Int64}}, ::tagged{Tuple{Colon}}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:45 [23] view @ ./subarray.jl:213 [inlined] [24] recurse(::ctx, ::typeof(view), ::tagged{Vector{Int64}}, ::tagged{Colon}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [25] overdub(::ctx, ::Function, ::tagged{Vector{Int64}}, ::tagged{Colon}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:45 [26] overdub(::ctx, ::typeof(Core._apply_iterate), ::Function, ::Function, ::tagged{Tuple{Vector{Int64}}}, ::tagged{Tuple{Colon}}) @ SparsityDetection ~/.julia/packages/Cassette/ROd5e/src/context.jl:264 [27] maybeview(::Vector{Int64}, ::Colon) @ ./views.jl:149 [inlined] [28] maybeview @ ./views.jl:149 [inlined] [29] recurse(::ctx, ::typeof(Base.maybeview), ::tagged{Vector{Int64}}, ::tagged{Colon}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [30] overdub(::ctx, ::Function, ::tagged{Vector{Int64}}, ::tagged{Colon}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:45 [31] overdub(ctx::ctx, ::typeof(Core._apply_iterate), iter::Function, f::Function, args::tagged{Tuple{Vector{Int64}, Colon}}) @ SparsityDetection ~/.julia/packages/Cassette/ROd5e/src/context.jl:264 [32] dotview(::Vector{Int64}, ::Colon) @ ./broadcast.jl:1228 [inlined] [33] dotview @ ./broadcast.jl:1228 [inlined] [34] recurse(::ctx, ::typeof(Base.Broadcast.dotview), ::tagged{Vector{Int64}}, ::Colon) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [35] overdub(::ctx, ::Function, ::tagged{Vector{Int64}}, ::Function) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:45 [36] (::var" @ ~/.julia/packages/SparsityDetection/E7o7R/test/jacobian.jl:18 [inlined] [37] g @ ~/.julia/packages/SparsityDetection/E7o7R/test/jacobian.jl:18 [inlined] [38] recurse(::ctx, ::var"#g#28", ::tagged{Vector{Int64}}, ::tagged{Vector{Int64}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [39] overdub(::ctx, ::Function, ::tagged{Vector{Int64}}, ::tagged{Vector{Int64}}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:45 [40] overdub @ ~/.julia/packages/Cassette/ROd5e/src/context.jl:264 [inlined] [41] (::SparsityDetection.var" @ ~/.julia/packages/SparsityDetection/E7o7R/src/controlflow.jl:148 [inlined] [42] #2 @ ~/.julia/packages/SparsityDetection/E7o7R/src/controlflow.jl:148 [inlined] [43] recurse(overdub_context#230::ctx, overdub_arguments#231::SparsityDetection.var"#2#3"{var"#g#28", Tuple{tagged{Vector{Int64}}, tagged{Vector{Int64}}}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [44] abstract_run(::SparsityDetection.var"#22#24", ::ctx, ::Function, ::tagged{Vector{Int64}}, ::Vararg{tagged{Vector{Int64}}}; verbose::Bool) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/controlflow.jl:148 [45] jacobian_sparsity(::Function, ::Vector{Int64}, ::Vector{Int64}; sparsity::Sparsity, verbose::Bool, raw::Bool) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/jacobian.jl:135 [46] jacobian_sparsity @ ~/.julia/packages/SparsityDetection/E7o7R/src/jacobian.jl:125 [inlined] [47] jactester(::Function, ::Vector{Int64}, ::Vector{Int64}) @ Main ~/.julia/packages/SparsityDetection/E7o7R/test/common.jl:14 [48] jactestmeta(::Function, ::Vararg{Any}) @ Main ~/.julia/packages/SparsityDetection/E7o7R/test/common.jl:17 [49] macro expansion @ ./timing.jl:581 [inlined] [50] macro expansion @ ~/.julia/packages/SparsityDetection/E7o7R/test/jacobian.jl:26 [inlined] [51] macro expansion @ /opt/julia/share/julia/stdlib/v1.11/Test/src/Test.jl:676 [inlined] y[1:2] .= x[2:3] Jacobian Sparsity: Error During Test at /home/pkgeval/.julia/packages/SparsityDetection/E7o7R/test/jacobian.jl:29 Test threw exception Expression: #= /home/pkgeval/.julia/packages/SparsityDetection/E7o7R/test/jacobian.jl:29 =# @time jacobian_sparsity(((y, x)->begin #= /home/pkgeval/.julia/packages/SparsityDetection/E7o7R/test/jacobian.jl:29 =# y[1:2] .= x[2:3] end), [1, 2, 3], [1, 2, 3]) == sparse([1, 2], [2, 3], true, 3, 3) MethodError: no method matching load(::Tuple{Int64}) The function `load` exists, but no method is defined for this combination of argument types. Closest candidates are: load(!Matched::Cassette.Immutable) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/tagging.jl:25 load(!Matched::Cassette.Mutable) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/tagging.jl:15 Stacktrace: [1] tagged_getfield @ ~/.julia/packages/Cassette/ROd5e/src/tagging.jl:629 [inlined] [2] tagged_getfield @ ~/.julia/packages/Cassette/ROd5e/src/tagging.jl:617 [inlined] [3] overdub @ ~/.julia/packages/Cassette/ROd5e/src/context.jl:287 [inlined] [4] size(::Vector{Int64}) @ ./array.jl:194 [inlined] [5] size @ ./array.jl:194 [inlined] [6] recurse(::ctx, ::typeof(size), ::tagged{Vector{Int64}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [7] overdub(ctx::ctx, f::Function, args::tagged{Vector{Int64}}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:45 [8] axes @ ./abstractarray.jl:98 [inlined] [9] recurse(::ctx, ::typeof(axes), ::tagged{Vector{Int64}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [10] overdub(ctx::ctx, f::Function, args::tagged{Vector{Int64}}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:45 [11] axes1(::Vector{Int64}) @ ./abstractarray.jl:137 [inlined] [12] axes1 @ ./abstractarray.jl:137 [inlined] [13] recurse(::ctx, ::typeof(Base.axes1), ::tagged{Vector{Int64}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [14] overdub(ctx::ctx, f::Function, args::tagged{Vector{Int64}}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:45 [15] eachindex(::IndexLinear, ::Vector{Int64}) @ ./abstractarray.jl:389 [inlined] [16] eachindex @ ./abstractarray.jl:389 [inlined] [17] recurse(::ctx, ::typeof(eachindex), ::IndexLinear, ::tagged{Vector{Int64}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [18] overdub(::ctx, ::Function, ::IndexLinear, ::tagged{Vector{Int64}}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:45 [19] to_indices(::Vector{Int64}, ::Tuple{UnitRange{Int64}}) @ ./indices.jl:360 [inlined] [20] to_indices @ ./indices.jl:360 [inlined] [21] recurse(::ctx, ::typeof(to_indices), ::tagged{Vector{Int64}}, ::tagged{Tuple{UnitRange{Int64}}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [22] overdub(::ctx, ::Function, ::tagged{Vector{Int64}}, ::tagged{Tuple{UnitRange{Int64}}}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:45 [23] view @ ./subarray.jl:213 [inlined] [24] recurse(::ctx, ::typeof(view), ::tagged{Vector{Int64}}, ::tagged{UnitRange{Int64}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [25] overdub(::ctx, ::Function, ::tagged{Vector{Int64}}, ::tagged{UnitRange{Int64}}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:45 [26] overdub(::ctx, ::typeof(Core._apply_iterate), ::Function, ::Function, ::tagged{Tuple{Vector{Int64}}}, ::tagged{Tuple{UnitRange{Int64}}}) @ SparsityDetection ~/.julia/packages/Cassette/ROd5e/src/context.jl:264 [27] maybeview(::Vector{Int64}, ::UnitRange{Int64}) @ ./views.jl:149 [inlined] [28] maybeview @ ./views.jl:149 [inlined] [29] recurse(::ctx, ::typeof(Base.maybeview), ::tagged{Vector{Int64}}, ::tagged{UnitRange{Int64}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [30] overdub(::ctx, ::Function, ::tagged{Vector{Int64}}, ::tagged{UnitRange{Int64}}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:45 [31] overdub(ctx::ctx, ::typeof(Core._apply_iterate), iter::Function, f::Function, args::tagged{Tuple{Vector{Int64}, UnitRange{Int64}}}) @ SparsityDetection ~/.julia/packages/Cassette/ROd5e/src/context.jl:264 [32] dotview(::Vector{Int64}, ::UnitRange{Int64}) @ ./broadcast.jl:1228 [inlined] [33] dotview @ ./broadcast.jl:1228 [inlined] [34] recurse(::ctx, ::typeof(Base.Broadcast.dotview), ::tagged{Vector{Int64}}, ::UnitRange{Int64}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [35] overdub(::ctx, ::Function, ::tagged{Vector{Int64}}, ::UnitRange{Int64}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:45 [36] (::var" @ ~/.julia/packages/SparsityDetection/E7o7R/test/jacobian.jl:29 [inlined] [37] #20 @ ~/.julia/packages/SparsityDetection/E7o7R/test/jacobian.jl:29 [inlined] [38] recurse(::ctx, ::var"#20#30", ::tagged{Vector{Int64}}, ::tagged{Vector{Int64}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [39] overdub(::ctx, ::Function, ::tagged{Vector{Int64}}, ::tagged{Vector{Int64}}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:45 [40] overdub @ ~/.julia/packages/Cassette/ROd5e/src/context.jl:264 [inlined] [41] (::SparsityDetection.var" @ ~/.julia/packages/SparsityDetection/E7o7R/src/controlflow.jl:148 [inlined] [42] #2 @ ~/.julia/packages/SparsityDetection/E7o7R/src/controlflow.jl:148 [inlined] [43] recurse(overdub_context#230::ctx, overdub_arguments#231::SparsityDetection.var"#2#3"{var"#20#30", Tuple{tagged{Vector{Int64}}, tagged{Vector{Int64}}}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [44] abstract_run(::SparsityDetection.var"#22#24", ::ctx, ::Function, ::tagged{Vector{Int64}}, ::Vararg{tagged{Vector{Int64}}}; verbose::Bool) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/controlflow.jl:148 [45] jacobian_sparsity(::Function, ::Vector{Int64}, ::Vector{Int64}; sparsity::Sparsity, verbose::Bool, raw::Bool) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/jacobian.jl:135 [46] jacobian_sparsity(::Function, ::Vector{Int64}, ::Vector{Int64}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/jacobian.jl:125 [47] macro expansion @ ./timing.jl:581 [inlined] [48] macro expansion @ ~/.julia/packages/SparsityDetection/E7o7R/test/jacobian.jl:29 [inlined] [49] macro expansion @ /opt/julia/share/julia/stdlib/v1.11/Test/src/Test.jl:676 [inlined] [50] top-level scope @ ~/.julia/packages/SparsityDetection/E7o7R/test/jacobian.jl:29 Jacobian Sparsity: Error During Test at /home/pkgeval/.julia/packages/SparsityDetection/E7o7R/test/jacobian.jl:38 Test threw exception Expression: jacobian_sparsity(testsparse!, out, x) == sparse([1, 2, 1, 2, 3, 2, 3, 4, 3, 4], [1, 1, 2, 2, 2, 3, 3, 3, 4, 4], true) MethodError: no method matching load(::Tuple{Int64}) The function `load` exists, but no method is defined for this combination of argument types. Closest candidates are: load(!Matched::Cassette.Immutable) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/tagging.jl:25 load(!Matched::Cassette.Mutable) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/tagging.jl:15 Stacktrace: [1] tagged_getfield @ ~/.julia/packages/Cassette/ROd5e/src/tagging.jl:629 [inlined] [2] tagged_getfield @ ~/.julia/packages/Cassette/ROd5e/src/tagging.jl:617 [inlined] [3] overdub @ ~/.julia/packages/Cassette/ROd5e/src/context.jl:287 [inlined] [4] size(::Vector{Int64}) @ ./array.jl:194 [inlined] [5] size @ ./array.jl:194 [inlined] [6] recurse(::ctx, ::typeof(size), ::tagged{Vector{Int64}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [7] overdub(ctx::ctx, f::Function, args::tagged{Vector{Int64}}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:45 [8] axes @ ./abstractarray.jl:98 [inlined] [9] recurse(::ctx, ::typeof(axes), ::tagged{Vector{Int64}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [10] overdub(ctx::ctx, f::Function, args::tagged{Vector{Int64}}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:45 [11] axes1(::Vector{Int64}) @ ./abstractarray.jl:137 [inlined] [12] axes1 @ ./abstractarray.jl:137 [inlined] [13] recurse(::ctx, ::typeof(Base.axes1), ::tagged{Vector{Int64}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [14] overdub(ctx::ctx, f::Function, args::tagged{Vector{Int64}}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:45 [15] eachindex(::IndexLinear, ::Vector{Int64}) @ ./abstractarray.jl:389 [inlined] [16] eachindex @ ./abstractarray.jl:389 [inlined] [17] recurse(::ctx, ::typeof(eachindex), ::IndexLinear, ::tagged{Vector{Int64}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [18] overdub(::ctx, ::Function, ::IndexLinear, ::tagged{Vector{Int64}}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:45 [19] lastindex(::Vector{Int64}) @ ./abstractarray.jl:426 [inlined] [20] lastindex @ ./abstractarray.jl:426 [inlined] [21] recurse(::ctx, ::typeof(lastindex), ::tagged{Vector{Int64}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [22] overdub(ctx::ctx, f::Function, args::tagged{Vector{Int64}}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:45 [23] (::var" @ ~/.julia/packages/SparsityDetection/E7o7R/test/jacobian.jl:34 [inlined] [24] testsparse! @ ~/.julia/packages/SparsityDetection/E7o7R/test/jacobian.jl:34 [inlined] [25] recurse(::ctx, ::var"#testsparse!#31", ::tagged{Vector{Int64}}, ::tagged{Vector{Int64}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [26] overdub(::ctx, ::Function, ::tagged{Vector{Int64}}, ::tagged{Vector{Int64}}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:45 [27] overdub @ ~/.julia/packages/Cassette/ROd5e/src/context.jl:264 [inlined] [28] (::SparsityDetection.var" @ ~/.julia/packages/SparsityDetection/E7o7R/src/controlflow.jl:148 [inlined] [29] #2 @ ~/.julia/packages/SparsityDetection/E7o7R/src/controlflow.jl:148 [inlined] [30] recurse(overdub_context#230::ctx, overdub_arguments#231::SparsityDetection.var"#2#3"{var"#testsparse!#31", Tuple{tagged{Vector{Int64}}, tagged{Vector{Int64}}}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [31] abstract_run(::SparsityDetection.var"#22#24", ::ctx, ::Function, ::tagged{Vector{Int64}}, ::Vararg{tagged{Vector{Int64}}}; verbose::Bool) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/controlflow.jl:148 [32] jacobian_sparsity(::Function, ::Vector{Int64}, ::Vector{Int64}; sparsity::Sparsity, verbose::Bool, raw::Bool) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/jacobian.jl:135 [33] jacobian_sparsity(::Function, ::Vector{Int64}, ::Vector{Int64}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/jacobian.jl:125 [34] macro expansion @ /opt/julia/share/julia/stdlib/v1.11/Test/src/Test.jl:676 [inlined] [35] top-level scope @ ~/.julia/packages/SparsityDetection/E7o7R/test/jacobian.jl:38 BLAS: Error During Test at /home/pkgeval/.julia/packages/SparsityDetection/E7o7R/test/jacobian.jl:51 Test threw exception Expression: all(jacobian_sparsity(f, out, x) .== 1) MethodError: no method matching load(::Tuple{Int64}) The function `load` exists, but no method is defined for this combination of argument types. Closest candidates are: load(!Matched::Cassette.Immutable) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/tagging.jl:25 load(!Matched::Cassette.Mutable) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/tagging.jl:15 Stacktrace: [1] tagged_getfield @ ~/.julia/packages/Cassette/ROd5e/src/tagging.jl:629 [inlined] [2] tagged_getfield @ ~/.julia/packages/Cassette/ROd5e/src/tagging.jl:617 [inlined] [3] overdub @ ~/.julia/packages/Cassette/ROd5e/src/context.jl:287 [inlined] [4] length(::Vector{Float64}) @ ./essentials.jl:11 [inlined] [5] length @ ./essentials.jl:11 [inlined] [6] recurse(::ctx, ::typeof(length), ::tagged{Vector{Float64}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [7] overdub(ctx::ctx, f::Function, args::tagged{Vector{Float64}}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:45 [8] (::var" @ ~/.julia/packages/SparsityDetection/E7o7R/test/jacobian.jl:44 [inlined] [9] f @ ~/.julia/packages/SparsityDetection/E7o7R/test/jacobian.jl:44 [inlined] [10] recurse(::ctx, ::var"#f#32", ::tagged{Vector{Float64}}, ::tagged{Vector{Float64}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [11] overdub(::ctx, ::Function, ::tagged{Vector{Float64}}, ::tagged{Vector{Float64}}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:45 [12] overdub @ ~/.julia/packages/Cassette/ROd5e/src/context.jl:264 [inlined] [13] (::SparsityDetection.var" @ ~/.julia/packages/SparsityDetection/E7o7R/src/controlflow.jl:148 [inlined] [14] #2 @ ~/.julia/packages/SparsityDetection/E7o7R/src/controlflow.jl:148 [inlined] [15] recurse(overdub_context#230::ctx, overdub_arguments#231::SparsityDetection.var"#2#3"{var"#f#32", Tuple{tagged{Vector{Float64}}, tagged{Vector{Float64}}}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [16] abstract_run(::SparsityDetection.var"#22#24", ::ctx, ::Function, ::tagged{Vector{Float64}}, ::Vararg{tagged{Vector{Float64}}}; verbose::Bool) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/controlflow.jl:148 [17] jacobian_sparsity(::Function, ::Vector{Float64}, ::Vector{Float64}; sparsity::Sparsity, verbose::Bool, raw::Bool) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/jacobian.jl:135 [18] jacobian_sparsity(::Function, ::Vector{Float64}, ::Vector{Float64}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/jacobian.jl:125 [19] macro expansion @ ~/.julia/packages/SparsityDetection/E7o7R/test/jacobian.jl:51 [inlined] [20] macro expansion @ /opt/julia/share/julia/stdlib/v1.11/Test/src/Test.jl:676 [inlined] [21] macro expansion @ ~/.julia/packages/SparsityDetection/E7o7R/test/jacobian.jl:51 [inlined] [22] macro expansion @ /opt/julia/share/julia/stdlib/v1.11/Test/src/Test.jl:1704 [inlined] [23] top-level scope @ ~/.julia/packages/SparsityDetection/E7o7R/test/jacobian.jl:43 avoid branches in primitive functions with isleaf: Error During Test at /home/pkgeval/.julia/packages/SparsityDetection/E7o7R/test/jacobian.jl:65 Test threw exception Expression: jacobian_sparsity(f, y, x) == sparse([1, 2, 3], [1, 2, 3], true) MethodError: no method matching load(::Tuple{Int64}) The function `load` exists, but no method is defined for this combination of argument types. Closest candidates are: load(!Matched::Cassette.Immutable) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/tagging.jl:25 load(!Matched::Cassette.Mutable) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/tagging.jl:15 Stacktrace: [1] tagged_getfield @ ~/.julia/packages/Cassette/ROd5e/src/tagging.jl:629 [inlined] [2] tagged_getfield @ ~/.julia/packages/Cassette/ROd5e/src/tagging.jl:617 [inlined] [3] overdub @ ~/.julia/packages/Cassette/ROd5e/src/context.jl:287 [inlined] [4] length(::Vector{Float64}) @ ./essentials.jl:11 [inlined] [5] length @ ./essentials.jl:11 [inlined] [6] recurse(::ctx, ::typeof(length), ::tagged{Vector{Float64}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [7] overdub(ctx::ctx, f::Function, args::tagged{Vector{Float64}}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:45 [8] (::var" @ ~/.julia/packages/SparsityDetection/E7o7R/test/jacobian.jl:60 [inlined] [9] f @ ~/.julia/packages/SparsityDetection/E7o7R/test/jacobian.jl:60 [inlined] [10] recurse(::ctx, ::var"#f#34", ::tagged{Vector{Float64}}, ::tagged{Vector{Float64}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [11] overdub(::ctx, ::Function, ::tagged{Vector{Float64}}, ::tagged{Vector{Float64}}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:45 [12] overdub @ ~/.julia/packages/Cassette/ROd5e/src/context.jl:264 [inlined] [13] (::SparsityDetection.var" @ ~/.julia/packages/SparsityDetection/E7o7R/src/controlflow.jl:148 [inlined] [14] #2 @ ~/.julia/packages/SparsityDetection/E7o7R/src/controlflow.jl:148 [inlined] [15] recurse(overdub_context#230::ctx, overdub_arguments#231::SparsityDetection.var"#2#3"{var"#f#34", Tuple{tagged{Vector{Float64}}, tagged{Vector{Float64}}}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [16] abstract_run(::SparsityDetection.var"#22#24", ::ctx, ::Function, ::tagged{Vector{Float64}}, ::Vararg{tagged{Vector{Float64}}}; verbose::Bool) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/controlflow.jl:148 [17] jacobian_sparsity(::Function, ::Vector{Float64}, ::Vector{Float64}; sparsity::Sparsity, verbose::Bool, raw::Bool) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/jacobian.jl:135 [18] jacobian_sparsity(::Function, ::Vector{Float64}, ::Vector{Float64}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/jacobian.jl:125 [19] macro expansion @ /opt/julia/share/julia/stdlib/v1.11/Test/src/Test.jl:676 [inlined] [20] macro expansion @ ~/.julia/packages/SparsityDetection/E7o7R/test/jacobian.jl:65 [inlined] [21] macro expansion @ /opt/julia/share/julia/stdlib/v1.11/Test/src/Test.jl:1704 [inlined] [22] top-level scope @ ~/.julia/packages/SparsityDetection/E7o7R/test/jacobian.jl:57 avoid branches in primitive functions with isleaf: Error During Test at /home/pkgeval/.julia/packages/SparsityDetection/E7o7R/test/jacobian.jl:69 Test threw exception Expression: jacobian_sparsity(y, x) do y, x #= /home/pkgeval/.julia/packages/SparsityDetection/E7o7R/test/jacobian.jl:70 =# y .= exp.(x) end == sparse([1, 2, 3], [1, 2, 3], [1, 1, 1]) MethodError: no method matching load(::Tuple{Int64}) The function `load` exists, but no method is defined for this combination of argument types. Closest candidates are: load(!Matched::Cassette.Immutable) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/tagging.jl:25 load(!Matched::Cassette.Mutable) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/tagging.jl:15 Stacktrace: [1] tagged_getfield @ ~/.julia/packages/Cassette/ROd5e/src/tagging.jl:629 [inlined] [2] tagged_getfield @ ~/.julia/packages/Cassette/ROd5e/src/tagging.jl:617 [inlined] [3] overdub @ ~/.julia/packages/Cassette/ROd5e/src/context.jl:287 [inlined] [4] size(::Vector{Float64}) @ ./array.jl:194 [inlined] [5] size @ ./array.jl:194 [inlined] [6] recurse(::ctx, ::typeof(size), ::tagged{Vector{Float64}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [7] overdub(ctx::ctx, f::Function, args::tagged{Vector{Float64}}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:45 [8] axes @ ./abstractarray.jl:98 [inlined] [9] recurse(::ctx, ::typeof(axes), ::tagged{Vector{Float64}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [10] overdub(ctx::ctx, f::Function, args::tagged{Vector{Float64}}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:45 [11] materialize!(::Base.Broadcast.DefaultArrayStyle{1}, ::Vector{Float64}, ::Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(exp), Tuple{Vector{Float64}}}) @ ./broadcast.jl:883 [inlined] [12] materialize! @ ./broadcast.jl:883 [inlined] [13] recurse(::ctx, ::typeof(Base.Broadcast.materialize!), ::Base.Broadcast.DefaultArrayStyle{1}, ::tagged{Vector{Float64}}, ::tagged{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(exp), Tuple{Vector{Float64}}}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [14] overdub(::ctx, ::Function, ::Base.Broadcast.DefaultArrayStyle{1}, ::tagged{Vector{Float64}}, ::tagged{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(exp), Tuple{Vector{Float64}}}}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:45 [15] materialize!(::Vector{Float64}, ::Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(exp), Tuple{Vector{Float64}}}) @ ./broadcast.jl:880 [inlined] [16] materialize! @ ./broadcast.jl:880 [inlined] [17] recurse(::ctx, ::typeof(Base.Broadcast.materialize!), ::tagged{Vector{Float64}}, ::tagged{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(exp), Tuple{Vector{Float64}}}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [18] overdub(::ctx, ::Function, ::tagged{Vector{Float64}}, ::tagged{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(exp), Tuple{Vector{Float64}}}}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:45 [19] (::var" @ ~/.julia/packages/SparsityDetection/E7o7R/test/jacobian.jl:70 [inlined] [20] #33 @ ~/.julia/packages/SparsityDetection/E7o7R/test/jacobian.jl:70 [inlined] [21] recurse(::ctx, ::var"#33#35", ::tagged{Vector{Float64}}, ::tagged{Vector{Float64}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [22] overdub(::ctx, ::Function, ::tagged{Vector{Float64}}, ::tagged{Vector{Float64}}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:45 [23] overdub @ ~/.julia/packages/Cassette/ROd5e/src/context.jl:264 [inlined] [24] (::SparsityDetection.var" @ ~/.julia/packages/SparsityDetection/E7o7R/src/controlflow.jl:148 [inlined] [25] #2 @ ~/.julia/packages/SparsityDetection/E7o7R/src/controlflow.jl:148 [inlined] [26] recurse(overdub_context#230::ctx, overdub_arguments#231::SparsityDetection.var"#2#3"{var"#33#35", Tuple{tagged{Vector{Float64}}, tagged{Vector{Float64}}}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [27] abstract_run(::SparsityDetection.var"#22#24", ::ctx, ::Function, ::tagged{Vector{Float64}}, ::Vararg{tagged{Vector{Float64}}}; verbose::Bool) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/controlflow.jl:148 [28] jacobian_sparsity(::Function, ::Vector{Float64}, ::Vector{Float64}; sparsity::Sparsity, verbose::Bool, raw::Bool) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/jacobian.jl:135 [29] jacobian_sparsity(::Function, ::Vector{Float64}, ::Vector{Float64}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/jacobian.jl:125 [30] macro expansion @ /opt/julia/share/julia/stdlib/v1.11/Test/src/Test.jl:676 [inlined] [31] macro expansion @ ~/.julia/packages/SparsityDetection/E7o7R/test/jacobian.jl:69 [inlined] [32] macro expansion @ /opt/julia/share/julia/stdlib/v1.11/Test/src/Test.jl:1704 [inlined] [33] top-level scope @ ~/.julia/packages/SparsityDetection/E7o7R/test/jacobian.jl:57 Fixed params: Error During Test at /home/pkgeval/.julia/packages/SparsityDetection/E7o7R/test/jacobian.jl:79 Test threw exception Expression: jacobian_sparsity(f, [1, 1, 1], [1, 2, 3], Fixed(1)) == sparse([1, 2, 3], [1, 2, 3], true) MethodError: no method matching load(::Tuple{Int64}) The function `load` exists, but no method is defined for this combination of argument types. Closest candidates are: load(!Matched::Cassette.Immutable) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/tagging.jl:25 load(!Matched::Cassette.Mutable) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/tagging.jl:15 Stacktrace: [1] tagged_getfield @ ~/.julia/packages/Cassette/ROd5e/src/tagging.jl:629 [inlined] [2] tagged_getfield @ ~/.julia/packages/Cassette/ROd5e/src/tagging.jl:617 [inlined] [3] overdub @ ~/.julia/packages/Cassette/ROd5e/src/context.jl:287 [inlined] [4] size(::Vector{Int64}) @ ./array.jl:194 [inlined] [5] size @ ./array.jl:194 [inlined] [6] recurse(::ctx, ::typeof(size), ::tagged{Vector{Int64}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [7] overdub(ctx::ctx, f::Function, args::tagged{Vector{Int64}}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:45 [8] axes @ ./abstractarray.jl:98 [inlined] [9] recurse(::ctx, ::typeof(axes), ::tagged{Vector{Int64}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [10] overdub(ctx::ctx, f::Function, args::tagged{Vector{Int64}}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:45 [11] materialize!(::Base.Broadcast.DefaultArrayStyle{1}, ::Vector{Int64}, ::Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(identity), Tuple{Vector{Int64}}}) @ ./broadcast.jl:883 [inlined] [12] materialize! @ ./broadcast.jl:883 [inlined] [13] recurse(::ctx, ::typeof(Base.Broadcast.materialize!), ::Base.Broadcast.DefaultArrayStyle{1}, ::tagged{Vector{Int64}}, ::tagged{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(identity), Tuple{Vector{Int64}}}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [14] overdub(::ctx, ::Function, ::Base.Broadcast.DefaultArrayStyle{1}, ::tagged{Vector{Int64}}, ::tagged{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(identity), Tuple{Vector{Int64}}}}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:45 [15] materialize!(::Vector{Int64}, ::Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(identity), Tuple{Vector{Int64}}}) @ ./broadcast.jl:880 [inlined] [16] materialize! @ ./broadcast.jl:880 [inlined] [17] recurse(::ctx, ::typeof(Base.Broadcast.materialize!), ::tagged{Vector{Int64}}, ::tagged{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(identity), Tuple{Vector{Int64}}}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [18] overdub(::ctx, ::Function, ::tagged{Vector{Int64}}, ::tagged{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(identity), Tuple{Vector{Int64}}}}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:45 [19] (::var" @ ~/.julia/packages/SparsityDetection/E7o7R/test/jacobian.jl:77 [inlined] [20] f @ ~/.julia/packages/SparsityDetection/E7o7R/test/jacobian.jl:77 [inlined] [21] recurse(::ctx, ::var"#f#36", ::tagged{Vector{Int64}}, ::tagged{Vector{Int64}}, ::Int64) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [22] overdub(::ctx, ::Function, ::tagged{Vector{Int64}}, ::tagged{Vector{Int64}}, ::Int64) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:45 [23] overdub @ ~/.julia/packages/Cassette/ROd5e/src/context.jl:264 [inlined] [24] (::SparsityDetection.var" @ ~/.julia/packages/SparsityDetection/E7o7R/src/controlflow.jl:148 [inlined] [25] #2 @ ~/.julia/packages/SparsityDetection/E7o7R/src/controlflow.jl:148 [inlined] [26] recurse(overdub_context#230::ctx, overdub_arguments#231::SparsityDetection.var"#2#3"{var"#f#36", Tuple{tagged{Vector{Int64}}, tagged{Vector{Int64}}, Int64}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [27] abstract_run(::SparsityDetection.var"#22#24", ::ctx, ::Function, ::tagged{Vector{Int64}}, ::Vararg{Any}; verbose::Bool) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/controlflow.jl:148 [28] jacobian_sparsity(f!::Function, Y::Vector{Int64}, X::Vector{Int64}, args::Fixed; sparsity::Sparsity, verbose::Bool, raw::Bool) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/jacobian.jl:135 [29] jacobian_sparsity(f!::Function, Y::Vector{Int64}, X::Vector{Int64}, args::Fixed) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/jacobian.jl:125 [30] macro expansion @ /opt/julia/share/julia/stdlib/v1.11/Test/src/Test.jl:676 [inlined] [31] macro expansion @ ~/.julia/packages/SparsityDetection/E7o7R/test/jacobian.jl:79 [inlined] [32] macro expansion @ /opt/julia/share/julia/stdlib/v1.11/Test/src/Test.jl:1704 [inlined] [33] top-level scope @ ~/.julia/packages/SparsityDetection/E7o7R/test/jacobian.jl:77 Fixed params: Error During Test at /home/pkgeval/.julia/packages/SparsityDetection/E7o7R/test/jacobian.jl:80 Test threw exception Expression: jacobian_sparsity(f, [1, 1, 1], [1, 2, 3], Fixed(-1)) == sparse([3, 2, 1], [1, 2, 3], true) MethodError: no method matching load(::Tuple{Int64}) The function `load` exists, but no method is defined for this combination of argument types. Closest candidates are: load(!Matched::Cassette.Immutable) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/tagging.jl:25 load(!Matched::Cassette.Mutable) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/tagging.jl:15 Stacktrace: [1] tagged_getfield @ ~/.julia/packages/Cassette/ROd5e/src/tagging.jl:629 [inlined] [2] tagged_getfield @ ~/.julia/packages/Cassette/ROd5e/src/tagging.jl:617 [inlined] [3] overdub @ ~/.julia/packages/Cassette/ROd5e/src/context.jl:287 [inlined] [4] size(::Vector{Int64}) @ ./array.jl:194 [inlined] [5] size @ ./array.jl:194 [inlined] [6] recurse(::ctx, ::typeof(size), ::tagged{Vector{Int64}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [7] overdub(ctx::ctx, f::Function, args::tagged{Vector{Int64}}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:45 [8] axes @ ./abstractarray.jl:98 [inlined] [9] recurse(::ctx, ::typeof(axes), ::tagged{Vector{Int64}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [10] overdub(ctx::ctx, f::Function, args::tagged{Vector{Int64}}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:45 [11] axes1(::Vector{Int64}) @ ./abstractarray.jl:137 [inlined] [12] axes1 @ ./abstractarray.jl:137 [inlined] [13] recurse(::ctx, ::typeof(Base.axes1), ::tagged{Vector{Int64}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [14] overdub(ctx::ctx, f::Function, args::tagged{Vector{Int64}}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:45 [15] eachindex(::IndexLinear, ::Vector{Int64}) @ ./abstractarray.jl:389 [inlined] [16] eachindex @ ./abstractarray.jl:389 [inlined] [17] recurse(::ctx, ::typeof(eachindex), ::IndexLinear, ::tagged{Vector{Int64}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [18] overdub(::ctx, ::Function, ::IndexLinear, ::tagged{Vector{Int64}}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:45 [19] firstindex(::Vector{Int64}) @ ./abstractarray.jl:449 [inlined] [20] firstindex @ ./abstractarray.jl:449 [inlined] [21] recurse(::ctx, ::typeof(firstindex), ::tagged{Vector{Int64}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [22] overdub(ctx::ctx, f::Function, args::tagged{Vector{Int64}}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:45 [23] _reverse(::Vector{Int64}, ::Colon) @ ./array.jl:2145 [inlined] [24] _reverse @ ./array.jl:2145 [inlined] [25] recurse(::ctx, ::typeof(Base._reverse), ::tagged{Vector{Int64}}, ::Colon) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [26] overdub(::ctx, ::Function, ::tagged{Vector{Int64}}, ::Function) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:45 [27] var" @ ./array.jl:2144 [inlined] [28] #reverse#142 @ ./array.jl:2144 [inlined] [29] recurse(::ctx, ::Base.var"##reverse#142", ::Colon, ::typeof(reverse), ::tagged{Vector{Int64}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [30] overdub(::ctx, ::Function, ::Function, ::Function, ::tagged{Vector{Int64}}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:45 [31] reverse(::Vector{Int64}) @ ./array.jl:2144 [inlined] [32] reverse @ ./array.jl:2144 [inlined] [33] recurse(::ctx, ::typeof(reverse), ::tagged{Vector{Int64}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [34] overdub(ctx::ctx, f::Function, args::tagged{Vector{Int64}}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:45 [35] (::var" @ ~/.julia/packages/SparsityDetection/E7o7R/test/jacobian.jl:77 [inlined] [36] f @ ~/.julia/packages/SparsityDetection/E7o7R/test/jacobian.jl:77 [inlined] [37] recurse(::ctx, ::var"#f#36", ::tagged{Vector{Int64}}, ::tagged{Vector{Int64}}, ::Int64) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [38] overdub(::ctx, ::Function, ::tagged{Vector{Int64}}, ::tagged{Vector{Int64}}, ::Int64) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:45 [39] overdub @ ~/.julia/packages/Cassette/ROd5e/src/context.jl:264 [inlined] [40] (::SparsityDetection.var" @ ~/.julia/packages/SparsityDetection/E7o7R/src/controlflow.jl:148 [inlined] [41] #2 @ ~/.julia/packages/SparsityDetection/E7o7R/src/controlflow.jl:148 [inlined] [42] recurse(overdub_context#230::ctx, overdub_arguments#231::SparsityDetection.var"#2#3"{var"#f#36", Tuple{tagged{Vector{Int64}}, tagged{Vector{Int64}}, Int64}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [43] abstract_run(::SparsityDetection.var"#22#24", ::ctx, ::Function, ::tagged{Vector{Int64}}, ::Vararg{Any}; verbose::Bool) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/controlflow.jl:148 [44] jacobian_sparsity(f!::Function, Y::Vector{Int64}, X::Vector{Int64}, args::Fixed; sparsity::Sparsity, verbose::Bool, raw::Bool) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/jacobian.jl:135 [45] jacobian_sparsity(f!::Function, Y::Vector{Int64}, X::Vector{Int64}, args::Fixed) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/jacobian.jl:125 [46] macro expansion @ /opt/julia/share/julia/stdlib/v1.11/Test/src/Test.jl:676 [inlined] [47] macro expansion @ ~/.julia/packages/SparsityDetection/E7o7R/test/jacobian.jl:80 [inlined] [48] macro expansion @ /opt/julia/share/julia/stdlib/v1.11/Test/src/Test.jl:1704 [inlined] [49] top-level scope @ ~/.julia/packages/SparsityDetection/E7o7R/test/jacobian.jl:77 Fixed params: Error During Test at /home/pkgeval/.julia/packages/SparsityDetection/E7o7R/test/jacobian.jl:81 Test threw exception Expression: jacobian_sparsity(f, [1, 1, 1], [1, 2, 3], 2) == sparse([1, 2, 3, 3, 1], [1, 2, 3, 1, 3], true) MethodError: no method matching load(::Tuple{Int64}) The function `load` exists, but no method is defined for this combination of argument types. Closest candidates are: load(!Matched::Cassette.Immutable) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/tagging.jl:25 load(!Matched::Cassette.Mutable) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/tagging.jl:15 Stacktrace: [1] tagged_getfield @ ~/.julia/packages/Cassette/ROd5e/src/tagging.jl:629 [inlined] [2] tagged_getfield @ ~/.julia/packages/Cassette/ROd5e/src/tagging.jl:617 [inlined] [3] overdub @ ~/.julia/packages/Cassette/ROd5e/src/context.jl:287 [inlined] [4] size(::Vector{Int64}) @ ./array.jl:194 [inlined] [5] size @ ./array.jl:194 [inlined] [6] recurse(::ctx, ::typeof(size), ::tagged{Vector{Int64}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [7] overdub(ctx::ctx, f::Function, args::tagged{Vector{Int64}}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:45 [8] axes @ ./abstractarray.jl:98 [inlined] [9] recurse(::ctx, ::typeof(axes), ::tagged{Vector{Int64}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [10] overdub(ctx::ctx, f::Function, args::tagged{Vector{Int64}}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:45 [11] materialize!(::Base.Broadcast.DefaultArrayStyle{1}, ::Vector{Int64}, ::Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(identity), Tuple{Vector{Int64}}}) @ ./broadcast.jl:883 [inlined] [12] materialize! @ ./broadcast.jl:883 [inlined] [13] recurse(::ctx, ::typeof(Base.Broadcast.materialize!), ::Base.Broadcast.DefaultArrayStyle{1}, ::tagged{Vector{Int64}}, ::tagged{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(identity), Tuple{Vector{Int64}}}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [14] overdub(::ctx, ::Function, ::Base.Broadcast.DefaultArrayStyle{1}, ::tagged{Vector{Int64}}, ::tagged{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(identity), Tuple{Vector{Int64}}}}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:45 [15] materialize!(::Vector{Int64}, ::Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(identity), Tuple{Vector{Int64}}}) @ ./broadcast.jl:880 [inlined] [16] materialize! @ ./broadcast.jl:880 [inlined] [17] recurse(::ctx, ::typeof(Base.Broadcast.materialize!), ::tagged{Vector{Int64}}, ::tagged{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(identity), Tuple{Vector{Int64}}}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [18] overdub(::ctx, ::Function, ::tagged{Vector{Int64}}, ::tagged{Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{1}, Nothing, typeof(identity), Tuple{Vector{Int64}}}}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:45 [19] (::var" @ ~/.julia/packages/SparsityDetection/E7o7R/test/jacobian.jl:77 [inlined] [20] f @ ~/.julia/packages/SparsityDetection/E7o7R/test/jacobian.jl:77 [inlined] [21] recurse(::ctx, ::var"#f#36", ::tagged{Vector{Int64}}, ::tagged{Vector{Int64}}, ::tagged{Int64}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [22] overdub(::ctx, ::Function, ::tagged{Vector{Int64}}, ::tagged{Vector{Int64}}, ::tagged{Int64}) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/propagate_tags.jl:45 [23] overdub @ ~/.julia/packages/Cassette/ROd5e/src/context.jl:264 [inlined] [24] (::SparsityDetection.var" @ ~/.julia/packages/SparsityDetection/E7o7R/src/controlflow.jl:148 [inlined] [25] #2 @ ~/.julia/packages/SparsityDetection/E7o7R/src/controlflow.jl:148 [inlined] [26] recurse(overdub_context#230::ctx, overdub_arguments#231::SparsityDetection.var"#2#3"{var"#f#36", Tuple{tagged{Vector{Int64}}, tagged{Vector{Int64}}, tagged{Int64}}}) @ Cassette ~/.julia/packages/Cassette/ROd5e/src/overdub.jl:0 [27] abstract_run(::SparsityDetection.var"#22#24", ::ctx, ::Function, ::tagged{Vector{Int64}}, ::Vararg{Any}; verbose::Bool) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/controlflow.jl:148 [28] jacobian_sparsity(f!::Function, Y::Vector{Int64}, X::Vector{Int64}, args::Int64; sparsity::Sparsity, verbose::Bool, raw::Bool) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/jacobian.jl:135 [29] jacobian_sparsity(f!::Function, Y::Vector{Int64}, X::Vector{Int64}, args::Int64) @ SparsityDetection ~/.julia/packages/SparsityDetection/E7o7R/src/jacobian.jl:125 [30] macro expansion @ /opt/julia/share/julia/stdlib/v1.11/Test/src/Test.jl:676 [inlined] [31] macro expansion @ ~/.julia/packages/SparsityDetection/E7o7R/test/jacobian.jl:81 [inlined] [32] macro expansion @ /opt/julia/share/julia/stdlib/v1.11/Test/src/Test.jl:1704 [inlined] [33] top-level scope @ ~/.julia/packages/SparsityDetection/E7o7R/test/jacobian.jl:77 Test Summary: | Pass Error Total Time Jacobian Sparsity | 5 13 18 3m04.4s BLAS | 1 1 4.2s avoid branches in primitive functions with isleaf | 2 2 22.3s Fixed params | 3 3 24.1s ERROR: LoadError: Some tests did not pass: 5 passed, 0 failed, 13 errored, 0 broken. in expression starting at /home/pkgeval/.julia/packages/SparsityDetection/E7o7R/test/runtests.jl:4 Testing failed after 194.29s ERROR: LoadError: Package SparsityDetection errored during testing Stacktrace: [1] pkgerror(msg::String) @ Pkg.Types /opt/julia/share/julia/stdlib/v1.11/Pkg/src/Types.jl:68 [2] test(ctx::Pkg.Types.Context, pkgs::Vector{Pkg.Types.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.11/Pkg/src/Operations.jl:2124 [3] test @ /opt/julia/share/julia/stdlib/v1.11/Pkg/src/Operations.jl:2007 [inlined] [4] test(ctx::Pkg.Types.Context, pkgs::Vector{Pkg.Types.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.11/Pkg/src/API.jl:481 [5] test(pkgs::Vector{Pkg.Types.PackageSpec}; io::IOContext{IO}, kwargs::@Kwargs{julia_args::Cmd}) @ Pkg.API /opt/julia/share/julia/stdlib/v1.11/Pkg/src/API.jl:159 [6] test @ /opt/julia/share/julia/stdlib/v1.11/Pkg/src/API.jl:147 [inlined] [7] #test#74 @ /opt/julia/share/julia/stdlib/v1.11/Pkg/src/API.jl:146 [inlined] [8] top-level scope @ /PkgEval.jl/scripts/evaluate.jl:219 in expression starting at /PkgEval.jl/scripts/evaluate.jl:210 PkgEval failed after 249.06s: package tests unexpectedly errored