Package evaluation to load DoubleEnded on Julia 1.14.0-DEV.2226 (797a5ef2b0*) started at 2026-05-23T17:38:54.140


################################################################################
# Set-up
#


Set-up completed after 0.11s


################################################################################
# Installation
#

Installing DoubleEnded...
   Resolving package versions...
   Installed OrderedCollections ─ v1.8.1
   Installed Compat ───────────── v4.18.1
   Installed ImmutableList ────── v0.1.1
   Installed ExportAll ────────── v0.1.2
   Installed DataStructures ───── v0.18.22
   Installed DoubleEnded ──────── v0.1.0
    Updating `~/.julia/environments/v1.14/Project.toml`
  [1bc4e7c2] + DoubleEnded v0.1.0
    Updating `~/.julia/environments/v1.14/Manifest.toml`
  [34da2185] + Compat v4.18.1
⌅ [864edb3b] + DataStructures v0.18.22
  [1bc4e7c2] + DoubleEnded v0.1.0
  [ad2082ca] + ExportAll v0.1.2
  [4a558cac] + ImmutableList v0.1.1
  [bac558e1] + OrderedCollections v1.8.1
  [2a0f44e3] + Base64 v1.11.0
  [ade2ca70] + Dates v1.11.0
  [b77e0a4c] + InteractiveUtils v1.11.0
  [ac6e5ff7] + JuliaSyntaxHighlighting v1.13.0
  [56ddb016] + Logging v1.11.0
  [d6f4376e] + Markdown v1.11.0
  [de0858da] + Printf v1.11.0
  [9a3f8284] + Random v1.11.0
  [ea8e919c] + SHA v1.13.0
  [9e88b42a] + Serialization v1.11.0
  [f489334b] + StyledStrings v1.13.0
  [fa267f1f] + TOML v1.0.3
  [8dfed614] + Test v1.11.0
  [cf7118a7] + UUIDs v1.11.0
  [4ec0a83e] + Unicode v1.11.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 5.69s


################################################################################
# Precompilation
#

Precompiling PkgEval dependencies...
     Project No packages added to or removed from `~/.julia/environments/pkgeval/Project.toml`
    Manifest No packages added to or removed from `~/.julia/environments/pkgeval/Manifest.toml`

Precompiling package dependencies...
Precompiling project...
 150.7 s  ✓ OrderedCollections
   1.4 s  ✓ Compat
ERROR: LoadError: LoweringError:
#= /home/pkgeval/.julia/packages/ImmutableList/oACVm/src/list.jl:72 =# - method definition declares type variable but does not use it in the type of any function parameter
Expression:
  (_typevar T core.Any core.Any)
Containing expressions:
  (_typevar T core.Any core.Any)

Detailed provenance:
  (_typevar T core.Any core.Any) @#= /source/usr/share/julia/JuliaLowering/src/desugaring.jl:3012 =#
  └─ T
     └─ T
        └─ T
           ├─ @ /home/pkgeval/.julia/packages/ImmutableList/oACVm/src/list.jl:72
           └─ (macrocall @doc :(#= /home/pkgeval/.julia/packages/ImmutableList/oACVm/src/list.jl:32 =#) "  This module provides an immutable list compatible with\n  the MetaModelica list datatype. It is immutable and supports common operations\n  associated with immutable single linked lists such as map and reduce.\n" (module true ListDef (block (struct false (curly Nil T) (block)) (struct false (curly Cons T) (block (:: head T) (:: tail (curly Union Nil (curly Cons T))))) (const (= (curly List T) (curly Union (curly Nil T) (curly Cons T) Nil))) (= (call List) (block (call (curly Nil Any)))) (= (call Nil) (block (call List))) (macrocall @doc :(#= /home/pkgeval/.julia/packages/ImmutableList/oACVm/src/list.jl:59 =#) " For converting lists with more then one element" (= (where (call (. Base (inert convert)) (:: (curly Type (curly List S))) (:: x (curly Cons T))) S (<: T S)) (block (let (block) (block (call List S x)))))) (macrocall @doc :(#= /home/pkgeval/.julia/packages/ImmutableList/oACVm/src/list.jl:64 =#) " For converting lists of lists " (= (where (call (. Base (inert convert)) (:: (curly Type T)) (:: x Cons)) (<: T List)) (block (let (block) (block (if (call isa x T) x (call List (call eltype T) x))))))) (= (where (call (. Base (inert convert)) (:: (curly Type (curly List T))) (:: x (curly Cons T))) T) (block x)) (= (where (call (. Base (inert convert)) (:: (curly Type (curly Cons T))) (:: x (curly Cons T))) T) (block x)) (= (where (call (. Base (inert convert)) (:: (curly Type Nil)) (:: x Nil)) T) (block nil)) (= (where (call (. Base (inert promote_rule)) (:: a (curly Type (curly Cons T))) (:: b (curly Type (curly Cons S)))) T S) (block (let (block) (block (call el_same (call promote_type T S) a b))))) (= (where (call (. Base (inert eltype)) (:: (curly Type (curly List T)))) T) (block (let (block) (block T)))) (= (where (call (. Base (inert eltype)) (:: (curly List T))) T) (block (let (block) (block T)))) (= (where (call (. Base (inert eltype)) (:: (curly Type (curly Cons T)))) T) (block (let (block) (block T)))) (= (where (call (. Base (inert eltype)) (:: (curly Type Nil))) T) (block (let (block) (block Nil)))) (= (where (call (. Base (inert eltype)) (:: Nil)) T) (block (let (block) (block Any)))) (macrocall @doc :(#= /home/pkgeval/.julia/packages/ImmutableList/oACVm/src/list.jl:99 =#) " O(n) " (function (where (:: (call listReverse (:: inLst (curly List T))) (curly List T)) T) (block (local (= (:: outLst List) nil)) (if (call isa inLst Nil) (block (return nil))) (while true (block (if (call isa inLst Nil) (block (break))) (= outLst (call (curly Cons T) (. inLst (inert head)) outLst)) (= inLst (. inLst (inert tail))))) outLst))) (macrocall @doc :(#= /home/pkgeval/.julia/packages/ImmutableList/oACVm/src/list.jl:116 =#) " For \"Efficient\" casting... O(N) * C\" " (= (call List (:: T Type) args) (block (let (block) (block (if (call isa args Nil) (block (return nil))) (local (= (:: lst1 (curly Cons T)) (call (curly Cons T) (call convert T (. args (inert head))) nil))) (if (call isa (. args (inert tail)) Nil) (block (return lst1))) (for (= i (. args (inert tail))) (block (= lst1 (call (curly Cons T) (call convert T i) lst1)))) (call listReverse lst1)))))) (const (= nil (call List))) (= (call list) (block nil)) (function (where (:: (call list (... (:: els T))) (curly List T)) (<: T Number)) (block (local (= (:: lst (curly List T)) nil)) (for (= i (call : (call length els) -1 1)) (block (= lst (call (curly Cons T) (ref els i) lst)))) lst)) (function (where (call list (:: a A) (:: b B) (... els)) A B) (block (local (= (:: S Type) (call typejoin A B (call eltype els)))) (macrocall @assert :(#= /home/pkgeval/.julia/packages/ImmutableList/oACVm/src/list.jl:147 =#) (call != S Any)) (local (= (:: lst (curly Cons S)) (call (curly Cons S) a (call (curly Cons S) b nil)))) (for (= i (call : (call length els) -1 1)) (block (= lst (call (curly Cons S) (ref els i) lst)))) lst)) (function (where (call list (:: a T)) T) (block (call (curly Cons T) a nil))) (function (where (call list (:: a A) (:: b B)) A B) (block (local (= (:: S Type) (call typejoin A B))) (macrocall @assert :(#= /home/pkgeval/.julia/packages/ImmutableList/oACVm/src/list.jl:163 =#) (call != S Any)) (call (curly Cons S) a (call (curly Cons S) b nil)))) (= (where (call cons (:: v T) (:: Nil)) T) (block (call (curly Cons T) v nil))) (= (where (call cons (:: v T) (:: l (curly Cons T))) T) (block (call (curly Cons T) v l))) (= (where (call cons (:: v A) (:: l (curly Cons B))) A B) (block (let (block) (block (= C (call typejoin A B)) (macrocall @assert :(#= /home/pkgeval/.julia/packages/ImmutableList/oACVm/src/list.jl:171 =#) (call != C Any)) (call (curly Cons C) (call convert C v) (call convert (curly Cons C) l)))))) (macrocall @doc :(#= /home/pkgeval/.julia/packages/ImmutableList/oACVm/src/list.jl:175 =#) "_cons is a special cons function that returns a list of the common\nabstract type instead of the type of the struct itself. Using this\nmay avoid future type conversions on the entire list to occur.\nUse this in particular in generated code where you cannot use cons\nresponsibly.\n" (function (where (call _cons (:: head A) (:: tail (curly Cons B))) A B) (block (= C (call typejoin A B)) (= D (call supertype C)) (if (&& (call isstructtype C) (&& (call ! (call isabstracttype C)) (call isabstracttype D))) (block (call (curly Cons D) (call convert D head) (call convert (curly List D) tail))) (block (call (curly Cons C) (call convert C head) (call convert (curly List C) tail))))))) (= (where (call _cons (:: head T) (:: tail Nil)) T) (block (call (curly Cons T) head nil))) (= (where (call consExternalC (:: (curly Type T)) (:: v X) (:: l (curly List T))) T (<: X T)) (block (call (curly Cons T) v l))) (macrocall @doc :(#= /home/pkgeval/.julia/packages/ImmutableList/oACVm/src/list.jl:195 =#) " <| Right associative cons operator " (= (call <| v (:: lst Nil)) (block (call cons v nil)))) (= (where (call <| v (:: lst (curly Cons T))) T) (block (call cons v lst))) (= (where (call <| (:: v S) (:: lst (curly Cons T))) T (<: S T)) (block (call cons v lst))) (= (:: (call (. Base (inert length)) (:: l Nil)) Int) (block 0)) (function (:: (call (. Base (inert length)) (:: l List)) Int) (block (local (= (:: n Int) 0)) (for (= _ l) (block (unknown_head n 1))) n)) (= (call (. Base (inert iterate)) (:: Nil)) (block nothing)) (= (call (. Base (inert iterate)) (:: x Cons) (:: y Nil)) (block nothing)) (function (call (. Base (inert iterate)) (:: l Cons) (kw (:: state List) l)) (block (tuple (. state (inert head)) (. state (inert tail))))) (macrocall @doc :(#= /home/pkgeval/.julia/packages/ImmutableList/oACVm/src/list.jl:216 =#) "  For list comprehension. Unless we switch to mutable structs this is the way to go I think.\n  Seems to be more efficient then what the omc currently does.\n" (= (call list F (:: C (. Base (inert Generator)))) (block (let (block) (block (call list (... (call collect (call (. Base (inert Generator)) F C))))))))) (macrocall @doc :(#= /home/pkgeval/.julia/packages/ImmutableList/oACVm/src/list.jl:224 =#) " Comprehension without a function(!) " (= (call list (:: C (. Base (inert Generator)))) (block (let (block) (block (call list (-> i (block i)) C)))))) (macrocall @doc :(#= /home/pkgeval/.julia/packages/ImmutableList/oACVm/src/list.jl:230 =#) " Adds the ability for Julia to flatten MMlists " (= (call list (:: X (. (. Base (inert Iterators)) (inert Flatten)))) (block (let (block) (block (call list (... (vect (... X))))))))) (macrocall @doc :(#= /home/pkgeval/.julia/packages/ImmutableList/oACVm/src/list.jl:235 =#) "  List Reductions\n" (= (where (call list (:: X (curly (. Base (inert Generator)) (curly (. (. Base (inert Iterators)) (inert ProductIterator)) Y) Z))) Y Z) (block (let (block) (block (= x (call collect X)) (call list (generator (call list (... i)) (= i (. view (tuple (vect x) (call : 1 (call size x 1)) :)))))))))) (macrocall @doc :(#= /home/pkgeval/.julia/packages/ImmutableList/oACVm/src/list.jl:243 =#) "Generates the transformation:\n @do_threaded_for expr with (iter_names) iterators =>\n  \$expr for \$iterator_names in list(zip(\$iters...)...)\n" (function (call make_threaded_for expr iter_names ranges) (block (= (:: iterExpr Expr) (call Expr (inert tuple) (... (. iter_names (inert args))))) (= (:: rangeExpr Expr) (= ranges (ref (vect (... ranges)) 1))) (= rangeExprArgs (. rangeExpr (inert args))) (call |> (quote (generator ($ expr) (= ($ iterExpr) (vect (... (call zip ($ (... rangeExprArgs)))))))) esc)))) (macro (call do_threaded_for (:: expr Expr) (:: iter_names Expr) (... ranges)) (block (call make_threaded_for expr iter_names ranges))) (macrocall @doc :(#= /home/pkgeval/.julia/packages/ImmutableList/oACVm/src/list.jl:259 =#) " Sorts the list by first converting it into an array " (= (call (. Base (inert sort)) (:: lst List)) (block (let (block) (block (call list (... (call sort (call collect lst))))))))) (export List list cons <| nil _cons) (export @do_threaded_for Cons Nil listReverse))))
              └─ @ /home/pkgeval/.julia/packages/ImmutableList/oACVm/src/list.jl:32

Stacktrace:
  [1] expand_function_def(ctx::Base.JuliaLowering.DesugaringContext{Dict{Symbol, Dict{Int64, Any}}}, src::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}}, raw_args::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, Vector{Int64}}, wheres::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, Vector{Int64}}, body::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}}, rett::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}})
    @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/desugaring.jl:2860
  [2] expand_forms_2(ctx::Base.JuliaLowering.DesugaringContext{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}}, docs::Nothing)
    @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/desugaring.jl:4268
  [3] Dict{Int64, Int64}()
    @ Base /source/usr/share/julia/JuliaLowering/src/desugaring.jl:4152 [inlined]
  [4] expand_forms_2(ctx::Base.JuliaLowering.MacroExpansionContext{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}})
    @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/desugaring.jl:4469
  [5] lower_step(iter::Base.JuliaLowering.LoweringIterator{Dict{Symbol, Dict{Int64, Any}}}, mod::Module, world::UInt64; soft_scope::Nothing)
    @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/eval.jl:90
  [6] getindex(A::Vector{Module}, i::Int64)
    @ Base /source/usr/share/julia/JuliaLowering/src/eval.jl:45 [inlined]
  [7] _eval(mod::Module, iter::Base.JuliaLowering.LoweringIterator{Dict{Symbol, Dict{Int64, Any}}}; soft_scope::Nothing)
    @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/eval.jl:479
  [8] _eval
    @ /source/usr/share/julia/JuliaLowering/src/eval.jl:475 [inlined]
  [9] #eval#134
    @ /source/usr/share/julia/JuliaLowering/src/eval.jl:467 [inlined]
 [10] top-level scope
    @ ~/.julia/packages/ImmutableList/oACVm/src/list.jl:32
 [11] macro expansion
    @ ~/.julia/packages/ImmutableList/oACVm/src/list.jl:32 [inlined]
 [12] include(mapexpr::Function, mod::Module, _path::String)
    @ Base ./Base.jl:327
 [13] top-level scope
    @ ~/.julia/packages/ImmutableList/oACVm/src/ImmutableList.jl:33
 [14] include(mod::Module, _path::String)
    @ Base ./Base.jl:326
 [15] 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:3271
 [16] top-level scope
    @ stdin:5
 [17] eval(m::Module, e::Any)
    @ Core ./boot.jl:517
 [18] include_string(mapexpr::typeof(identity), mod::Module, code::String, filename::String)
    @ Base ./loading.jl:3113
 [19] push!(a::Vector{SubString{String}}, item::String)
    @ Base ./loading.jl:3123 [inlined]
 [20] exec_options(opts::Base.JLOptions)
    @ Base ./client.jl:353
 [21] _start()
    @ Base ./client.jl:596
in expression starting at /home/pkgeval/.julia/packages/ImmutableList/oACVm/src/list.jl:32
in expression starting at /home/pkgeval/.julia/packages/ImmutableList/oACVm/src/ImmutableList.jl:32
in expression starting at stdin:5
              ✗ ImmutableList
   0.7 s  ✓ ExportAll
   0.6 s  ✓ Compat → CompatLinearAlgebraExt
 298.9 s  ✓ DataStructures
ERROR: LoadError: Precompiled image Base.PkgId(Base.UUID("4a558cac-c1ed-11e9-20da-3584bcd8709a"), "ImmutableList") not available with flags CacheFlags(; use_pkgimages=false, debug_level=1, check_bounds=1, inline=true, opt_level=0)
Stacktrace:
  [1] error(s::String)
    @ Base ./error.jl:56
  [2] __require_prelocked(pkg::Base.PkgId, env::String)
    @ Base ./loading.jl:2818
  [3] _require_prelocked(uuidkey::Base.PkgId, env::String)
    @ Base ./loading.jl:2672
  [4] macro expansion
    @ ./loading.jl:2599 [inlined]
  [5] string(::String, ::Union{Char, SubString{String}, String, Symbol}, ::Symbol, ::String)
    @ Base ./lock.jl:376 [inlined]
  [6] __require(into::Module, mod::Symbol)
    @ Base ./loading.jl:2563
  [7] require
    @ ./loading.jl:2539 [inlined]
  [8] eval_import_path(at::Module, from::Nothing, path::Expr, keyword::String)
    @ Base ./module.jl:36 [inlined]
  [9] eval_import_path_all(at::Module, path::Expr, keyword::String)
    @ Base ./module.jl:60
 [10] _eval_using(to::Module, path::Expr, flags::UInt8)
    @ Base ./module.jl:137 [inlined]
 [11] eval_using(to::Module, path::Expr)
    @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/runtime.jl:207
 [12] top-level scope
    @ ~/.julia/packages/DoubleEnded/17lyf/src/DoubleEnded.jl:34
 [13] include(mod::Module, _path::String)
    @ Base ./Base.jl:326
 [14] 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:3271
 [15] top-level scope
    @ stdin:5
 [16] eval(m::Module, e::Any)
    @ Core ./boot.jl:517
 [17] include_string(mapexpr::typeof(identity), mod::Module, code::String, filename::String)
    @ Base ./loading.jl:3113
 [18] push!(a::Vector{SubString{String}}, item::String)
    @ Base ./loading.jl:3123 [inlined]
 [19] exec_options(opts::Base.JLOptions)
    @ Base ./client.jl:353
 [20] _start()
    @ Base ./client.jl:596
in expression starting at /home/pkgeval/.julia/packages/DoubleEnded/17lyf/src/DoubleEnded.jl:25
in expression starting at stdin:5
              ✗ DoubleEnded
  5 dependencies successfully precompiled in 496 seconds. 13 already precompiled.

Precompilation completed after 513.18s


################################################################################
# Loading
#

Loading DoubleEnded...
ERROR: LoadError: LoweringError:
#= /home/pkgeval/.julia/packages/ImmutableList/oACVm/src/list.jl:72 =# - method definition declares type variable but does not use it in the type of any function parameter
Expression:
  (_typevar T core.Any core.Any)
Containing expressions:
  (_typevar T core.Any core.Any)

Detailed provenance:
  (_typevar T core.Any core.Any) @#= /source/usr/share/julia/JuliaLowering/src/desugaring.jl:3012 =#
  └─ T
     └─ T
        └─ T
           ├─ @ /home/pkgeval/.julia/packages/ImmutableList/oACVm/src/list.jl:72
           └─ (macrocall @doc :(#= /home/pkgeval/.julia/packages/ImmutableList/oACVm/src/list.jl:32 =#) "  This module provides an immutable list compatible with\n  the MetaModelica list datatype. It is immutable and supports common operations\n  associated with immutable single linked lists such as map and reduce.\n" (module true ListDef (block (struct false (curly Nil T) (block)) (struct false (curly Cons T) (block (:: head T) (:: tail (curly Union Nil (curly Cons T))))) (const (= (curly List T) (curly Union (curly Nil T) (curly Cons T) Nil))) (= (call List) (block (call (curly Nil Any)))) (= (call Nil) (block (call List))) (macrocall @doc :(#= /home/pkgeval/.julia/packages/ImmutableList/oACVm/src/list.jl:59 =#) " For converting lists with more then one element" (= (where (call (. Base (inert convert)) (:: (curly Type (curly List S))) (:: x (curly Cons T))) S (<: T S)) (block (let (block) (block (call List S x)))))) (macrocall @doc :(#= /home/pkgeval/.julia/packages/ImmutableList/oACVm/src/list.jl:64 =#) " For converting lists of lists " (= (where (call (. Base (inert convert)) (:: (curly Type T)) (:: x Cons)) (<: T List)) (block (let (block) (block (if (call isa x T) x (call List (call eltype T) x))))))) (= (where (call (. Base (inert convert)) (:: (curly Type (curly List T))) (:: x (curly Cons T))) T) (block x)) (= (where (call (. Base (inert convert)) (:: (curly Type (curly Cons T))) (:: x (curly Cons T))) T) (block x)) (= (where (call (. Base (inert convert)) (:: (curly Type Nil)) (:: x Nil)) T) (block nil)) (= (where (call (. Base (inert promote_rule)) (:: a (curly Type (curly Cons T))) (:: b (curly Type (curly Cons S)))) T S) (block (let (block) (block (call el_same (call promote_type T S) a b))))) (= (where (call (. Base (inert eltype)) (:: (curly Type (curly List T)))) T) (block (let (block) (block T)))) (= (where (call (. Base (inert eltype)) (:: (curly List T))) T) (block (let (block) (block T)))) (= (where (call (. Base (inert eltype)) (:: (curly Type (curly Cons T)))) T) (block (let (block) (block T)))) (= (where (call (. Base (inert eltype)) (:: (curly Type Nil))) T) (block (let (block) (block Nil)))) (= (where (call (. Base (inert eltype)) (:: Nil)) T) (block (let (block) (block Any)))) (macrocall @doc :(#= /home/pkgeval/.julia/packages/ImmutableList/oACVm/src/list.jl:99 =#) " O(n) " (function (where (:: (call listReverse (:: inLst (curly List T))) (curly List T)) T) (block (local (= (:: outLst List) nil)) (if (call isa inLst Nil) (block (return nil))) (while true (block (if (call isa inLst Nil) (block (break))) (= outLst (call (curly Cons T) (. inLst (inert head)) outLst)) (= inLst (. inLst (inert tail))))) outLst))) (macrocall @doc :(#= /home/pkgeval/.julia/packages/ImmutableList/oACVm/src/list.jl:116 =#) " For \"Efficient\" casting... O(N) * C\" " (= (call List (:: T Type) args) (block (let (block) (block (if (call isa args Nil) (block (return nil))) (local (= (:: lst1 (curly Cons T)) (call (curly Cons T) (call convert T (. args (inert head))) nil))) (if (call isa (. args (inert tail)) Nil) (block (return lst1))) (for (= i (. args (inert tail))) (block (= lst1 (call (curly Cons T) (call convert T i) lst1)))) (call listReverse lst1)))))) (const (= nil (call List))) (= (call list) (block nil)) (function (where (:: (call list (... (:: els T))) (curly List T)) (<: T Number)) (block (local (= (:: lst (curly List T)) nil)) (for (= i (call : (call length els) -1 1)) (block (= lst (call (curly Cons T) (ref els i) lst)))) lst)) (function (where (call list (:: a A) (:: b B) (... els)) A B) (block (local (= (:: S Type) (call typejoin A B (call eltype els)))) (macrocall @assert :(#= /home/pkgeval/.julia/packages/ImmutableList/oACVm/src/list.jl:147 =#) (call != S Any)) (local (= (:: lst (curly Cons S)) (call (curly Cons S) a (call (curly Cons S) b nil)))) (for (= i (call : (call length els) -1 1)) (block (= lst (call (curly Cons S) (ref els i) lst)))) lst)) (function (where (call list (:: a T)) T) (block (call (curly Cons T) a nil))) (function (where (call list (:: a A) (:: b B)) A B) (block (local (= (:: S Type) (call typejoin A B))) (macrocall @assert :(#= /home/pkgeval/.julia/packages/ImmutableList/oACVm/src/list.jl:163 =#) (call != S Any)) (call (curly Cons S) a (call (curly Cons S) b nil)))) (= (where (call cons (:: v T) (:: Nil)) T) (block (call (curly Cons T) v nil))) (= (where (call cons (:: v T) (:: l (curly Cons T))) T) (block (call (curly Cons T) v l))) (= (where (call cons (:: v A) (:: l (curly Cons B))) A B) (block (let (block) (block (= C (call typejoin A B)) (macrocall @assert :(#= /home/pkgeval/.julia/packages/ImmutableList/oACVm/src/list.jl:171 =#) (call != C Any)) (call (curly Cons C) (call convert C v) (call convert (curly Cons C) l)))))) (macrocall @doc :(#= /home/pkgeval/.julia/packages/ImmutableList/oACVm/src/list.jl:175 =#) "_cons is a special cons function that returns a list of the common\nabstract type instead of the type of the struct itself. Using this\nmay avoid future type conversions on the entire list to occur.\nUse this in particular in generated code where you cannot use cons\nresponsibly.\n" (function (where (call _cons (:: head A) (:: tail (curly Cons B))) A B) (block (= C (call typejoin A B)) (= D (call supertype C)) (if (&& (call isstructtype C) (&& (call ! (call isabstracttype C)) (call isabstracttype D))) (block (call (curly Cons D) (call convert D head) (call convert (curly List D) tail))) (block (call (curly Cons C) (call convert C head) (call convert (curly List C) tail))))))) (= (where (call _cons (:: head T) (:: tail Nil)) T) (block (call (curly Cons T) head nil))) (= (where (call consExternalC (:: (curly Type T)) (:: v X) (:: l (curly List T))) T (<: X T)) (block (call (curly Cons T) v l))) (macrocall @doc :(#= /home/pkgeval/.julia/packages/ImmutableList/oACVm/src/list.jl:195 =#) " <| Right associative cons operator " (= (call <| v (:: lst Nil)) (block (call cons v nil)))) (= (where (call <| v (:: lst (curly Cons T))) T) (block (call cons v lst))) (= (where (call <| (:: v S) (:: lst (curly Cons T))) T (<: S T)) (block (call cons v lst))) (= (:: (call (. Base (inert length)) (:: l Nil)) Int) (block 0)) (function (:: (call (. Base (inert length)) (:: l List)) Int) (block (local (= (:: n Int) 0)) (for (= _ l) (block (unknown_head n 1))) n)) (= (call (. Base (inert iterate)) (:: Nil)) (block nothing)) (= (call (. Base (inert iterate)) (:: x Cons) (:: y Nil)) (block nothing)) (function (call (. Base (inert iterate)) (:: l Cons) (kw (:: state List) l)) (block (tuple (. state (inert head)) (. state (inert tail))))) (macrocall @doc :(#= /home/pkgeval/.julia/packages/ImmutableList/oACVm/src/list.jl:216 =#) "  For list comprehension. Unless we switch to mutable structs this is the way to go I think.\n  Seems to be more efficient then what the omc currently does.\n" (= (call list F (:: C (. Base (inert Generator)))) (block (let (block) (block (call list (... (call collect (call (. Base (inert Generator)) F C))))))))) (macrocall @doc :(#= /home/pkgeval/.julia/packages/ImmutableList/oACVm/src/list.jl:224 =#) " Comprehension without a function(!) " (= (call list (:: C (. Base (inert Generator)))) (block (let (block) (block (call list (-> i (block i)) C)))))) (macrocall @doc :(#= /home/pkgeval/.julia/packages/ImmutableList/oACVm/src/list.jl:230 =#) " Adds the ability for Julia to flatten MMlists " (= (call list (:: X (. (. Base (inert Iterators)) (inert Flatten)))) (block (let (block) (block (call list (... (vect (... X))))))))) (macrocall @doc :(#= /home/pkgeval/.julia/packages/ImmutableList/oACVm/src/list.jl:235 =#) "  List Reductions\n" (= (where (call list (:: X (curly (. Base (inert Generator)) (curly (. (. Base (inert Iterators)) (inert ProductIterator)) Y) Z))) Y Z) (block (let (block) (block (= x (call collect X)) (call list (generator (call list (... i)) (= i (. view (tuple (vect x) (call : 1 (call size x 1)) :)))))))))) (macrocall @doc :(#= /home/pkgeval/.julia/packages/ImmutableList/oACVm/src/list.jl:243 =#) "Generates the transformation:\n @do_threaded_for expr with (iter_names) iterators =>\n  \$expr for \$iterator_names in list(zip(\$iters...)...)\n" (function (call make_threaded_for expr iter_names ranges) (block (= (:: iterExpr Expr) (call Expr (inert tuple) (... (. iter_names (inert args))))) (= (:: rangeExpr Expr) (= ranges (ref (vect (... ranges)) 1))) (= rangeExprArgs (. rangeExpr (inert args))) (call |> (quote (generator ($ expr) (= ($ iterExpr) (vect (... (call zip ($ (... rangeExprArgs)))))))) esc)))) (macro (call do_threaded_for (:: expr Expr) (:: iter_names Expr) (... ranges)) (block (call make_threaded_for expr iter_names ranges))) (macrocall @doc :(#= /home/pkgeval/.julia/packages/ImmutableList/oACVm/src/list.jl:259 =#) " Sorts the list by first converting it into an array " (= (call (. Base (inert sort)) (:: lst List)) (block (let (block) (block (call list (... (call sort (call collect lst))))))))) (export List list cons <| nil _cons) (export @do_threaded_for Cons Nil listReverse))))
              └─ @ /home/pkgeval/.julia/packages/ImmutableList/oACVm/src/list.jl:32

Stacktrace:
  [1] expand_function_def(ctx::Base.JuliaLowering.DesugaringContext{Dict{Symbol, Dict{Int64, Any}}}, src::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}}, raw_args::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, Vector{Int64}}, wheres::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, Vector{Int64}}, body::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}}, rett::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}})
    @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/desugaring.jl:2860
  [2] expand_forms_2(ctx::Base.JuliaLowering.DesugaringContext{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}}, docs::Nothing)
    @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/desugaring.jl:4268
  [3] Dict{Int64, Int64}()
    @ Base /source/usr/share/julia/JuliaLowering/src/desugaring.jl:4152 [inlined]
  [4] expand_forms_2(ctx::Base.JuliaLowering.MacroExpansionContext{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}})
    @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/desugaring.jl:4469
  [5] lower_step(iter::Base.JuliaLowering.LoweringIterator{Dict{Symbol, Dict{Int64, Any}}}, mod::Module, world::UInt64; soft_scope::Nothing)
    @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/eval.jl:90
  [6] getindex(A::Vector{Module}, i::Int64)
    @ Base /source/usr/share/julia/JuliaLowering/src/eval.jl:45 [inlined]
  [7] _eval(mod::Module, iter::Base.JuliaLowering.LoweringIterator{Dict{Symbol, Dict{Int64, Any}}}; soft_scope::Nothing)
    @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/eval.jl:479
  [8] _eval
    @ /source/usr/share/julia/JuliaLowering/src/eval.jl:475 [inlined]
  [9] #eval#134
    @ /source/usr/share/julia/JuliaLowering/src/eval.jl:467 [inlined]
 [10] top-level scope
    @ ~/.julia/packages/ImmutableList/oACVm/src/list.jl:32
 [11] macro expansion
    @ ~/.julia/packages/ImmutableList/oACVm/src/list.jl:32 [inlined]
 [12] include(mapexpr::Function, mod::Module, _path::String)
    @ Base ./Base.jl:327
 [13] top-level scope
    @ ~/.julia/packages/ImmutableList/oACVm/src/ImmutableList.jl:33
 [14] include(mod::Module, _path::String)
    @ Base ./Base.jl:326
 [15] 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:3271
 [16] top-level scope
    @ stdin:5
 [17] eval(m::Module, e::Any)
    @ Core ./boot.jl:517
 [18] include_string(mapexpr::typeof(identity), mod::Module, code::String, filename::String)
    @ Base ./loading.jl:3113
 [19] push!(a::Vector{SubString{String}}, item::String)
    @ Base ./loading.jl:3123 [inlined]
 [20] exec_options(opts::Base.JLOptions)
    @ Base ./client.jl:353
 [21] _start()
    @ Base ./client.jl:596
in expression starting at /home/pkgeval/.julia/packages/ImmutableList/oACVm/src/list.jl:32
in expression starting at /home/pkgeval/.julia/packages/ImmutableList/oACVm/src/ImmutableList.jl:32
in expression starting at stdin:5
ERROR: LoadError: Precompiled image Base.PkgId(Base.UUID("4a558cac-c1ed-11e9-20da-3584bcd8709a"), "ImmutableList") not available with flags CacheFlags(; use_pkgimages=false, debug_level=1, check_bounds=1, inline=true, opt_level=0)
Stacktrace:
  [1] error(s::String)
    @ Base ./error.jl:56
  [2] __require_prelocked(pkg::Base.PkgId, env::String)
    @ Base ./loading.jl:2818
  [3] _require_prelocked(uuidkey::Base.PkgId, env::String)
    @ Base ./loading.jl:2672
  [4] macro expansion
    @ ./loading.jl:2599 [inlined]
  [5] string(::String, ::Union{Char, SubString{String}, String, Symbol}, ::Symbol, ::String)
    @ Base ./lock.jl:376 [inlined]
  [6] __require(into::Module, mod::Symbol)
    @ Base ./loading.jl:2563
  [7] require
    @ ./loading.jl:2539 [inlined]
  [8] eval_import_path(at::Module, from::Nothing, path::Expr, keyword::String)
    @ Base ./module.jl:36 [inlined]
  [9] eval_import_path_all(at::Module, path::Expr, keyword::String)
    @ Base ./module.jl:60
 [10] _eval_using(to::Module, path::Expr, flags::UInt8)
    @ Base ./module.jl:137 [inlined]
 [11] eval_using(to::Module, path::Expr)
    @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/runtime.jl:207
 [12] top-level scope
    @ ~/.julia/packages/DoubleEnded/17lyf/src/DoubleEnded.jl:34
 [13] include(mod::Module, _path::String)
    @ Base ./Base.jl:326
 [14] 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:3271
 [15] top-level scope
    @ stdin:5
 [16] eval(m::Module, e::Any)
    @ Core ./boot.jl:517
 [17] include_string(mapexpr::typeof(identity), mod::Module, code::String, filename::String)
    @ Base ./loading.jl:3113
 [18] push!(a::Vector{SubString{String}}, item::String)
    @ Base ./loading.jl:3123 [inlined]
 [19] exec_options(opts::Base.JLOptions)
    @ Base ./client.jl:353
 [20] _start()
    @ Base ./client.jl:596
in expression starting at /home/pkgeval/.julia/packages/DoubleEnded/17lyf/src/DoubleEnded.jl:25
in expression starting at stdin:5
  2 dependencies had output during precompilation:
┌ ImmutableList
│  ERROR: LoadError: LoweringError:
│  #= /home/pkgeval/.julia/packages/ImmutableList/oACVm/src/list.jl:72 =# - method definition declares type variable but does not use it in the type of any function parameter
│  Expression:
│    (_typevar T core.Any core.Any)
│  Containing expressions:
│    (_typevar T core.Any core.Any)
│  
│  Detailed provenance:
│    (_typevar T core.Any core.Any) @#= /source/usr/share/julia/JuliaLowering/src/desugaring.jl:3012 =#
│    └─ T
│       └─ T
│          └─ T
│             ├─ @ /home/pkgeval/.julia/packages/ImmutableList/oACVm/src/list.jl:72
│             └─ (macrocall @doc :(#= /home/pkgeval/.julia/packages/ImmutableList/oACVm/src/list.jl:32 =#) "  This module provides an immutable list compatible with\n  the MetaModelica list datatype. It is immutable and supports common operations\n  associated with immutable single linked lists such as map and reduce.\n" (module true ListDef (block (struct false (curly Nil T) (block)) (struct false (curly Cons T) (block (:: head T) (:: tail (curly Union Nil (curly Cons T))))) (const (= (curly List T) (curly Union (curly Nil T) (curly Cons T) Nil))) (= (call List) (block (call (curly Nil Any)))) (= (call Nil) (block (call List))) (macrocall @doc :(#= /home/pkgeval/.julia/packages/ImmutableList/oACVm/src/list.jl:59 =#) " For converting lists with more then one element" (= (where (call (. Base (inert convert)) (:: (curly Type (curly List S))) (:: x (curly Cons T))) S (<: T S)) (block (let (block) (block (call List S x)))))) (macrocall @doc :(#= /home/pkgeval/.julia/packages/ImmutableList/oACVm/src/list.jl:64 =#) " For converting lists of lists " (= (where (call (. Base (inert convert)) (:: (curly Type T)) (:: x Cons)) (<: T List)) (block (let (block) (block (if (call isa x T) x (call List (call eltype T) x))))))) (= (where (call (. Base (inert convert)) (:: (curly Type (curly List T))) (:: x (curly Cons T))) T) (block x)) (= (where (call (. Base (inert convert)) (:: (curly Type (curly Cons T))) (:: x (curly Cons T))) T) (block x)) (= (where (call (. Base (inert convert)) (:: (curly Type Nil)) (:: x Nil)) T) (block nil)) (= (where (call (. Base (inert promote_rule)) (:: a (curly Type (curly Cons T))) (:: b (curly Type (curly Cons S)))) T S) (block (let (block) (block (call el_same (call promote_type T S) a b))))) (= (where (call (. Base (inert eltype)) (:: (curly Type (curly List T)))) T) (block (let (block) (block T)))) (= (where (call (. Base (inert eltype)) (:: (curly List T))) T) (block (let (block) (block T)))) (= (where (call (. Base (inert eltype)) (:: (curly Type (curly Cons T)))) T) (block (let (block) (block T)))) (= (where (call (. Base (inert eltype)) (:: (curly Type Nil))) T) (block (let (block) (block Nil)))) (= (where (call (. Base (inert eltype)) (:: Nil)) T) (block (let (block) (block Any)))) (macrocall @doc :(#= /home/pkgeval/.julia/packages/ImmutableList/oACVm/src/list.jl:99 =#) " O(n) " (function (where (:: (call listReverse (:: inLst (curly List T))) (curly List T)) T) (block (local (= (:: outLst List) nil)) (if (call isa inLst Nil) (block (return nil))) (while true (block (if (call isa inLst Nil) (block (break))) (= outLst (call (curly Cons T) (. inLst (inert head)) outLst)) (= inLst (. inLst (inert tail))))) outLst))) (macrocall @doc :(#= /home/pkgeval/.julia/packages/ImmutableList/oACVm/src/list.jl:116 =#) " For \"Efficient\" casting... O(N) * C\" " (= (call List (:: T Type) args) (block (let (block) (block (if (call isa args Nil) (block (return nil))) (local (= (:: lst1 (curly Cons T)) (call (curly Cons T) (call convert T (. args (inert head))) nil))) (if (call isa (. args (inert tail)) Nil) (block (return lst1))) (for (= i (. args (inert tail))) (block (= lst1 (call (curly Cons T) (call convert T i) lst1)))) (call listReverse lst1)))))) (const (= nil (call List))) (= (call list) (block nil)) (function (where (:: (call list (... (:: els T))) (curly List T)) (<: T Number)) (block (local (= (:: lst (curly List T)) nil)) (for (= i (call : (call length els) -1 1)) (block (= lst (call (curly Cons T) (ref els i) lst)))) lst)) (function (where (call list (:: a A) (:: b B) (... els)) A B) (block (local (= (:: S Type) (call typejoin A B (call eltype els)))) (macrocall @assert :(#= /home/pkgeval/.julia/packages/ImmutableList/oACVm/src/list.jl:147 =#) (call != S Any)) (local (= (:: lst (curly Cons S)) (call (curly Cons S) a (call (curly Cons S) b nil)))) (for (= i (call : (call length els) -1 1)) (block (= lst (call (curly Cons S) (ref els i) lst)))) lst)) (function (where (call list (:: a T)) T) (block (call (curly Cons T) a nil))) (function (where (call list (:: a A) (:: b B)) A B) (block (local (= (:: S Type) (call typejoin A B))) (macrocall @assert :(#= /home/pkgeval/.julia/packages/ImmutableList/oACVm/src/list.jl:163 =#) (call != S Any)) (call (curly Cons S) a (call (curly Cons S) b nil)))) (= (where (call cons (:: v T) (:: Nil)) T) (block (call (curly Cons T) v nil))) (= (where (call cons (:: v T) (:: l (curly Cons T))) T) (block (call (curly Cons T) v l))) (= (where (call cons (:: v A) (:: l (curly Cons B))) A B) (block (let (block) (block (= C (call typejoin A B)) (macrocall @assert :(#= /home/pkgeval/.julia/packages/ImmutableList/oACVm/src/list.jl:171 =#) (call != C Any)) (call (curly Cons C) (call convert C v) (call convert (curly Cons C) l)))))) (macrocall @doc :(#= /home/pkgeval/.julia/packages/ImmutableList/oACVm/src/list.jl:175 =#) "_cons is a special cons function that returns a list of the common\nabstract type instead of the type of the struct itself. Using this\nmay avoid future type conversions on the entire list to occur.\nUse this in particular in generated code where you cannot use cons\nresponsibly.\n" (function (where (call _cons (:: head A) (:: tail (curly Cons B))) A B) (block (= C (call typejoin A B)) (= D (call supertype C)) (if (&& (call isstructtype C) (&& (call ! (call isabstracttype C)) (call isabstracttype D))) (block (call (curly Cons D) (call convert D head) (call convert (curly List D) tail))) (block (call (curly Cons C) (call convert C head) (call convert (curly List C) tail))))))) (= (where (call _cons (:: head T) (:: tail Nil)) T) (block (call (curly Cons T) head nil))) (= (where (call consExternalC (:: (curly Type T)) (:: v X) (:: l (curly List T))) T (<: X T)) (block (call (curly Cons T) v l))) (macrocall @doc :(#= /home/pkgeval/.julia/packages/ImmutableList/oACVm/src/list.jl:195 =#) " <| Right associative cons operator " (= (call <| v (:: lst Nil)) (block (call cons v nil)))) (= (where (call <| v (:: lst (curly Cons T))) T) (block (call cons v lst))) (= (where (call <| (:: v S) (:: lst (curly Cons T))) T (<: S T)) (block (call cons v lst))) (= (:: (call (. Base (inert length)) (:: l Nil)) Int) (block 0)) (function (:: (call (. Base (inert length)) (:: l List)) Int) (block (local (= (:: n Int) 0)) (for (= _ l) (block (unknown_head n 1))) n)) (= (call (. Base (inert iterate)) (:: Nil)) (block nothing)) (= (call (. Base (inert iterate)) (:: x Cons) (:: y Nil)) (block nothing)) (function (call (. Base (inert iterate)) (:: l Cons) (kw (:: state List) l)) (block (tuple (. state (inert head)) (. state (inert tail))))) (macrocall @doc :(#= /home/pkgeval/.julia/packages/ImmutableList/oACVm/src/list.jl:216 =#) "  For list comprehension. Unless we switch to mutable structs this is the way to go I think.\n  Seems to be more efficient then what the omc currently does.\n" (= (call list F (:: C (. Base (inert Generator)))) (block (let (block) (block (call list (... (call collect (call (. Base (inert Generator)) F C))))))))) (macrocall @doc :(#= /home/pkgeval/.julia/packages/ImmutableList/oACVm/src/list.jl:224 =#) " Comprehension without a function(!) " (= (call list (:: C (. Base (inert Generator)))) (block (let (block) (block (call list (-> i (block i)) C)))))) (macrocall @doc :(#= /home/pkgeval/.julia/packages/ImmutableList/oACVm/src/list.jl:230 =#) " Adds the ability for Julia to flatten MMlists " (= (call list (:: X (. (. Base (inert Iterators)) (inert Flatten)))) (block (let (block) (block (call list (... (vect (... X))))))))) (macrocall @doc :(#= /home/pkgeval/.julia/packages/ImmutableList/oACVm/src/list.jl:235 =#) "  List Reductions\n" (= (where (call list (:: X (curly (. Base (inert Generator)) (curly (. (. Base (inert Iterators)) (inert ProductIterator)) Y) Z))) Y Z) (block (let (block) (block (= x (call collect X)) (call list (generator (call list (... i)) (= i (. view (tuple (vect x) (call : 1 (call size x 1)) :)))))))))) (macrocall @doc :(#= /home/pkgeval/.julia/packages/ImmutableList/oACVm/src/list.jl:243 =#) "Generates the transformation:\n @do_threaded_for expr with (iter_names) iterators =>\n  \$expr for \$iterator_names in list(zip(\$iters...)...)\n" (function (call make_threaded_for expr iter_names ranges) (block (= (:: iterExpr Expr) (call Expr (inert tuple) (... (. iter_names (inert args))))) (= (:: rangeExpr Expr) (= ranges (ref (vect (... ranges)) 1))) (= rangeExprArgs (. rangeExpr (inert args))) (call |> (quote (generator ($ expr) (= ($ iterExpr) (vect (... (call zip ($ (... rangeExprArgs)))))))) esc)))) (macro (call do_threaded_for (:: expr Expr) (:: iter_names Expr) (... ranges)) (block (call make_threaded_for expr iter_names ranges))) (macrocall @doc :(#= /home/pkgeval/.julia/packages/ImmutableList/oACVm/src/list.jl:259 =#) " Sorts the list by first converting it into an array " (= (call (. Base (inert sort)) (:: lst List)) (block (let (block) (block (call list (... (call sort (call collect lst))))))))) (export List list cons <| nil _cons) (export @do_threaded_for Cons Nil listReverse))))
│                └─ @ /home/pkgeval/.julia/packages/ImmutableList/oACVm/src/list.jl:32
│  
│  Stacktrace:
│    [1] expand_function_def(ctx::Base.JuliaLowering.DesugaringContext{Dict{Symbol, Dict{Int64, Any}}}, src::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}}, raw_args::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, Vector{Int64}}, wheres::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, Vector{Int64}}, body::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}}, rett::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}})
│      @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/desugaring.jl:2860
│    [2] expand_forms_2(ctx::Base.JuliaLowering.DesugaringContext{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}}, docs::Nothing)
│      @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/desugaring.jl:4268
│    [3] Dict{Int64, Int64}()
│      @ Base /source/usr/share/julia/JuliaLowering/src/desugaring.jl:4152 [inlined]
│    [4] expand_forms_2(ctx::Base.JuliaLowering.MacroExpansionContext{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}})
│      @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/desugaring.jl:4469
│    [5] lower_step(iter::Base.JuliaLowering.LoweringIterator{Dict{Symbol, Dict{Int64, Any}}}, mod::Module, world::UInt64; soft_scope::Nothing)
│      @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/eval.jl:90
│    [6] getindex(A::Vector{Module}, i::Int64)
│      @ Base /source/usr/share/julia/JuliaLowering/src/eval.jl:45 [inlined]
│    [7] _eval(mod::Module, iter::Base.JuliaLowering.LoweringIterator{Dict{Symbol, Dict{Int64, Any}}}; soft_scope::Nothing)
│      @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/eval.jl:479
│    [8] _eval
│      @ /source/usr/share/julia/JuliaLowering/src/eval.jl:475 [inlined]
│    [9] #eval#134
│      @ /source/usr/share/julia/JuliaLowering/src/eval.jl:467 [inlined]
│   [10] top-level scope
│      @ ~/.julia/packages/ImmutableList/oACVm/src/list.jl:32
│   [11] macro expansion
│      @ ~/.julia/packages/ImmutableList/oACVm/src/list.jl:32 [inlined]
│   [12] include(mapexpr::Function, mod::Module, _path::String)
│      @ Base ./Base.jl:327
│   [13] top-level scope
│      @ ~/.julia/packages/ImmutableList/oACVm/src/ImmutableList.jl:33
│   [14] include(mod::Module, _path::String)
│      @ Base ./Base.jl:326
│   [15] 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:3271
│   [16] top-level scope
│      @ stdin:5
│   [17] eval(m::Module, e::Any)
│      @ Core ./boot.jl:517
│   [18] include_string(mapexpr::typeof(identity), mod::Module, code::String, filename::String)
│      @ Base ./loading.jl:3113
│   [19] push!(a::Vector{SubString{String}}, item::String)
│      @ Base ./loading.jl:3123 [inlined]
│   [20] exec_options(opts::Base.JLOptions)
│      @ Base ./client.jl:353
│   [21] _start()
│      @ Base ./client.jl:596
│  in expression starting at /home/pkgeval/.julia/packages/ImmutableList/oACVm/src/list.jl:32
│  in expression starting at /home/pkgeval/.julia/packages/ImmutableList/oACVm/src/ImmutableList.jl:32
│  in expression starting at stdin:5
└  
┌ DoubleEnded
│  [Output was shown above]
└  
ERROR: The following 2 packages failed to precompile:

ImmutableList 
Failed to precompile ImmutableList [4a558cac-c1ed-11e9-20da-3584bcd8709a] to "/home/pkgeval/.julia/compiled/v1.14/ImmutableList/jl_OOzq80" (ProcessExited(1)).

DoubleEnded 
Failed to precompile DoubleEnded [1bc4e7c2-c1e1-11e9-03fe-315bbef43fde] to "/home/pkgeval/.julia/compiled/v1.14/DoubleEnded/jl_fvjv5m" (ProcessExited(1)).


Loading failed after 52.08s

ERROR: LoadError: failed process: Process(`/opt/julia/bin/julia -C native -J/opt/julia/lib/julia/sys.so -g1 --check-bounds=yes --inline=yes --check-bounds=yes --pkgimages=existing -e 'using DoubleEnded'`, ProcessExited(1)) [1]

Stacktrace:
 [1] spawn_opts_inherit()
   @ Base ./process.jl:612 [inlined]
 [2] run(::Cmd; wait::Bool)
   @ Base ./process.jl:525
 [3] run(::Cmd)
   @ Base ./process.jl:522
 [4] top-level scope
   @ /PkgEval.jl/scripts/evaluate.jl:197
 [5] include(mod::Module, _path::String)
   @ Base ./Base.jl:326
 [6] exec_options(opts::Base.JLOptions)
   @ Base ./client.jl:355
 [7] _start()
   @ Base ./client.jl:596
in expression starting at /PkgEval.jl/scripts/evaluate.jl:188

PkgEval failed after 592.26s: package fails to precompile