Package evaluation to test GeometryBasics on Julia 1.14.0-DEV.2226 (797a5ef2b0*) started at 2026-05-23T20:35:10.382 ################################################################################ # Set-up # Installing PkgEval dependencies (TestEnv)... Activating project at `~/.julia/environments/v1.14` Set-up completed after 16.51s ################################################################################ # Installation # Installing GeometryBasics... Resolving package versions... Installed EarCut_jll ─────── v2.2.4+0 Installed GeometryBasics ─── v0.5.10 Installed IterTools ──────── v1.10.0 Installed StaticArraysCore ─ v1.4.4 Installed Extents ────────── v0.1.6 Installed JLLWrappers ────── v1.8.0 Installed StaticArrays ───── v1.9.18 Installed Preferences ────── v1.5.2 Installed PrecompileTools ── v1.3.4 Installing 1 artifacts Installed artifact EarCut 80.5 KiB Updating `~/.julia/environments/v1.14/Project.toml` [5c1252a2] + GeometryBasics v0.5.10 Updating `~/.julia/environments/v1.14/Manifest.toml` [411431e0] + Extents v0.1.6 [5c1252a2] + GeometryBasics v0.5.10 [c8e1da08] + IterTools v1.10.0 [692b3bcd] + JLLWrappers v1.8.0 [aea7be01] + PrecompileTools v1.3.4 [21216c6a] + Preferences v1.5.2 [90137ffa] + StaticArrays v1.9.18 [1e83bf80] + StaticArraysCore v1.4.4 [5ae413db] + EarCut_jll v2.2.4+0 [0dad84c5] + ArgTools v1.1.2 [56f22d72] + Artifacts v1.11.0 [2a0f44e3] + Base64 v1.11.0 [ade2ca70] + Dates v1.11.0 [f43a241f] + Downloads v1.7.0 [7b1f6079] + FileWatching v1.11.0 [ac6e5ff7] + JuliaSyntaxHighlighting v1.13.0 [b27032c2] + LibCURL v1.0.0 [76f85450] + LibGit2 v1.11.0 [8f399da3] + Libdl v1.11.0 [37e2e46d] + LinearAlgebra v1.13.0 [56ddb016] + Logging v1.11.0 [d6f4376e] + Markdown v1.11.0 [ca575930] + NetworkOptions v1.3.0 [44cfe95a] + Pkg v1.14.0 [de0858da] + Printf v1.11.0 [9a3f8284] + Random v1.11.0 [ea8e919c] + SHA v1.13.0 [f489334b] + StyledStrings v1.13.0 [fa267f1f] + TOML v1.0.3 [a4e569a6] + Tar v1.10.0 [cf7118a7] + UUIDs v1.11.0 [4ec0a83e] + Unicode v1.11.0 [e66e0078] + CompilerSupportLibraries_jll v1.5.1+0 [deac9b47] + LibCURL_jll v8.20.0+1 [e37daf67] + LibGit2_jll v1.9.3+0 [29816b5a] + LibSSH2_jll v1.11.101+0 [14a3606d] + MozillaCACerts_jll v2026.5.14 [4536629a] + OpenBLAS_jll v0.3.33+0 [458c3c95] + OpenSSL_jll v3.5.6+0 [efcefdf7] + PCRE2_jll v10.47.0+0 [83775a58] + Zlib_jll v1.3.2+0 [3161d3a3] + Zstd_jll v1.5.7+1 [8e850b90] + libblastrampoline_jll v5.15.0+0 [8e850ede] + nghttp2_jll v1.69.0+0 [3f19e933] + p7zip_jll v17.8.0+0 Installation completed after 7.47s ################################################################################ # Precompilation # Precompiling PkgEval dependencies... Precompiling project... 5.5 s ✓ TestEnv 1 dependency successfully precompiled in 6 seconds. 27 already precompiled. Precompiling package dependencies... Precompiling project... 1.0 s ✓ DataAPI 0.5 s ✓ DataValueInterfaces 0.9 s ✓ StaticArraysCore 1.2 s ✓ Extents 147.5 s ✓ OrderedCollections 437.5 s ✓ IterTools 76.4 s ✓ OffsetArrays 129.7 s ✓ GeoFormatTypes 0.5 s ✓ IteratorInterfaceExtensions 2.9 s ✓ StructTypes 1.4 s ✓ Compat 2.1 s ✓ Preferences 98.3 s ✓ GeoInterface 0.5 s ✓ TableTraits 0.6 s ✓ Compat → CompatLinearAlgebraExt 2.6 s ✓ JLLWrappers 2.4 s ✓ PrecompileTools 162.5 s ✓ Tables 38.2 s ✓ Aqua 2.8 s ✓ EarCut_jll 298.8 s ✓ StaticArrays 26.3 s ✓ Parsers ┌ Info: JuliaLowering threw given input: │ code = │ :(#= /home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl:453 =# Core.@doc " Mesh{PositionDim, PositionType, FaceType, VertexAttributeNames, VertexAttributeTypes, FaceVectorType} <: AbstractMesh{PositionDim, PositionType} <: AbstractGeometry{PositionDim, PositionType}\n\nThe type of a concrete mesh. The associated struct contains 3 fields:\n\n```julia\nstruct Mesh{...}\n vertex_attributes::NamedTuple{VertexAttributeNames, VertexAttributeTypes}\n faces::FaceVectorType\n views::Vector{UnitRange{Int}}\nend\n```\n\nA vertex typically carries multiple distinct pieces of data, e.g. a position,\na normal, a texture coordinate, etc. We call those pieces of data vertex\nattributes. The `vertex_attributes` field contains the name and a collection\n`<: AbstractVector` or `<: FaceView` for each attribute. The n-th element of that\ncollection is the value of the corresponding attribute for the n-th vertex.\n\n```julia\n# vertex 1 2 3\nvertex_attributes[:position] = [pos1, pos2, pos3, ...]\nvertex_attributes[:normal] = [normal1, normal2, normal3, ...]\n...\n```\n\nA `NamedTuple` is used here to allow different meshes to carry different vertex\nattributes while also keeping things type stable. The constructor enforces a\nfew restrictions:\n- The first attribute must be named `position` and must have a `Point{PositionDim, PositionType}` eltype.\n- Each vertex attribute must refer to the same number of vertices. (All vertex attributes defined by\nAbstractVector must match in length. For FaceViews, the number of faces needs to match.)\n\nSee also: [`vertex_attributes`](@ref), [`coordinates`](@ref), [`normals`](@ref),\n[`texturecoordinates`](@ref), [`decompose`](@ref), [`FaceView`](@ref),\n[`expand_faceviews`](@ref)\n\nThe `faces` field is a collection `<: AbstractVector{FaceType}` containing faces\nthat describe how vertices are connected. Typically these are `(GL)TriangleFace`s\nor `QuadFace`s, but they can be any collection of vertex indices `<: AbstractFace`.\n\nSee also: [`faces`](@ref), [`decompose`](@ref)\n\nThe `views` field can be used to separate the mesh into mutliple submeshes. Each\nsubmesh is described by a \"view\" into the `faces` vector, i.e. submesh n uses\n`mesh.faces[mesh.views[n]]`. A `Mesh` can be constructed without `views`, which\nresults in an empty `views` vector.\n\nSee also: [`merge`](@ref), [`split_mesh`](@ref)\n" struct Mesh{Dim, T <: Real, FT <: AbstractFace, Names, VAT <: Tuple{<:AbstractVector{Point{Dim, T}}, Vararg{VertexAttributeType}}, FVT <: AbstractVector{FT}} <: AbstractMesh{Dim, T} │ #= /home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl:511 =# │ vertex_attributes::NamedTuple{Names, VAT} │ #= /home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl:512 =# │ faces::FVT │ #= /home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl:513 =# │ views::Vector{UnitRange{UInt32}} │ #= /home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl:515 =# │ function Mesh(vertex_attributes::NamedTuple{Names, VAT}, fs::FVT, views::Vector{<:UnitRange{<:Integer}} = UnitRange{UInt32}[]) where {FT <: AbstractFace, FVT <: AbstractVector{FT}, Names, Dim, T, VAT <: Tuple{<:AbstractVector{Point{Dim, T}}, Vararg{VertexAttributeType}}} │ #= /home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl:515 =# │ #= /home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl:524 =# │ va = vertex_attributes │ #= /home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl:525 =# │ names = Names │ #= /home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl:528 =# │ if !(haskey(va, :position)) │ #= /home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl:529 =# │ error("Vertex attributes must have a :position attribute.") │ end │ #= /home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl:532 =# │ if haskey(va, :normals) │ #= /home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl:533 =# │ #= /home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl:533 =# @warn "`normals` as a vertex attribute name has been deprecated in favor of `normal` to bring it in line with mesh.position and mesh.uv" │ #= /home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl:534 =# │ names = ntuple((i->begin │ #= /home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl:534 =# │ ifelse(names[i] == :normal, :normal, names[i]) │ end), length(names)) │ #= /home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl:535 =# │ va = NamedTuple{names}(values(va)) │ end │ #= /home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl:541 =# │ N = maximum((f->begin │ #= /home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl:541 =# │ value(maximum(f)) │ end), fs, init = 0) │ #= /home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl:542 =# │ for (name, attrib) = pairs(va) │ #= /home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl:543 =# │ if attrib isa FaceView │ #= /home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl:544 =# │ try │ #= /home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl:545 =# │ verify(fs, attrib) │ catch e │ #= /home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl:547 =# │ rethrow(ErrorException("Failed to verify $(name) attribute:\n$(e.msg)")) │ end │ else │ #= /home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl:550 =# │ length(attrib) < N && error("Failed to verify $(name) attribute:\nFaces address $(N) vertex attributes but only $(length(attrib)) are present.") │ end │ #= /home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl:552 =# │ end │ #= /home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl:554 =# │ return new{Dim, T, FT, names, VAT, FVT}(va, fs, views) │ end │ end) │ st0 = │ SyntaxTree with attributes mod,kind,var_id,toplevel_pure,scope_type,macro_source,name_val,syntax_flags,meta,scope_layer,value,jl_source,is_toplevel_thunk,source,__macro_ctx__ │ [macrocall] │ │ @doc :: Identifier │ mod │ :(#= /home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl:453 =#) :: Value │ │ " Mesh{PositionDim, PositionType, FaceType, VertexAttributeNames, VertexAttributeTypes, FaceVectorType} <: AbstractMesh{PositionDim, PositionType} <: AbstractGeometry{PositionDim, PositionType}\n\nThe type of a concrete mesh. The associated struct contains 3 fields:\n\n```julia\nstruct Mesh{...}\n vertex_attributes::NamedTuple{VertexAttributeNames, VertexAttributeTypes}\n faces::FaceVectorType\n views::Vector{UnitRange{Int}}\nend\n```\n\nA vertex typically carries multiple distinct pieces of data, e.g. a position,\na normal, a texture coordinate, etc. We call those pieces of data vertex\nattributes. The `vertex_attributes` field contains the name and a collection\n`<: AbstractVector` or `<: FaceView` for each attribute. The n-th element of that\ncollection is the value of the corresponding attribute for the n-th vertex.\n\n```julia\n# vertex 1 2 3\nvertex_attributes[:position] = [pos1, pos2, pos3, ...]\nvertex_attributes[:normal] = [normal1, normal2, normal3, ...]\n...\n```\n\nA `NamedTuple` is used here to allow different meshes to carry different vertex\nattributes while also keeping things type stable. The constructor enforces a\nfew restrictions:\n- The first attribute must be named `position` and must have a `Point{PositionDim, PositionType}` eltype.\n- Each vertex attribute must refer to the same number of vertices. (All vertex attributes defined by\nAbstractVector must match in length. For FaceViews, the number of faces needs to match.)\n\nSee also: [`vertex_attributes`](@ref), [`coordinates`](@ref), [`normals`](@ref),\n[`texturecoordinates`](@ref), [`decompose`](@ref), [`FaceView`](@ref),\n[`expand_faceviews`](@ref)\n\nThe `faces` field is a collection `<: AbstractVector{FaceType}` containing faces\nthat describe how vertices are connected. Typically these are `(GL)TriangleFace`s\nor `QuadFace`s, but they can be any collection of vertex indices `<: AbstractFace`.\n\nSee also: [`faces`](@ref), [`decompose`](@ref)\n\nThe `views` field can be used to separate the mesh into mutliple submeshes. Each\nsubmesh is described by a \"view\" into the `faces` vector, i.e. submesh n uses\n`mesh.faces[mesh.views[n]]`. A `Mesh` can be constructed without `views`, which\nresults in an empty `views` vector.\n\nSee also: [`merge`](@ref), [`split_mesh`](@ref)\n" :: Value │ │ [struct] │ │ false :: Value │ │ [<:] │ │ [curly] │ │ Mesh :: Identifier │ │ Dim :: Identifier │ │ [<:] │ │ T :: Identifier │ │ Real :: Identifier │ │ [<:] │ │ FT :: Identifier │ │ AbstractFace :: Identifier │ │ Names :: Identifier │ │ [<:] │ │ VAT :: Identifier │ │ [curly] │ │ Tuple :: Identifier │ │ [<:] │ │ [curly] │ │ AbstractVector :: Identifier │ │ [curly] │ │ Point :: Identifier │ │ Dim :: Identifier │ │ T :: Identifier │ │ [curly] │ │ Vararg :: Identifier │ │ VertexAttributeType :: Identifier │ │ [<:] │ │ FVT :: Identifier │ │ [curly] │ │ AbstractVector :: Identifier │ │ FT :: Identifier │ │ [curly] │ │ AbstractMesh :: Identifier │ │ Dim :: Identifier │ │ T :: Identifier │ │ [block] │ │ [::] │ │ vertex_attributes :: Identifier │ │ [curly] │ │ NamedTuple :: Identifier │ │ Names :: Identifier │ │ VAT :: Identifier │ │ [::] │ │ faces :: Identifier │ │ FVT :: Identifier │ │ [::] │ │ views :: Identifier │ │ [curly] │ │ Vector :: Identifier │ │ [curly] │ │ UnitRange :: Identifier │ │ UInt32 :: Identifier │ │ [function] │ │ [where] │ │ [call] │ │ Mesh :: Identifier │ │ [::] │ │ vertex_attributes :: Identifier │ │ [curly] │ │ NamedTuple :: Identifier │ │ Names :: Identifier │ │ VAT :: Identifier │ │ [::] │ │ fs :: Identifier │ │ FVT :: Identifier │ │ [kw] │ │ [::] │ │ views :: Identifier │ │ [curly] │ │ Vector :: Identifier │ │ [<:] │ │ [curly] │ │ UnitRange :: Identifier │ │ [<:] │ │ Integer :: Identifier │ │ [ref] │ │ [curly] │ │ UnitRange :: Identifier │ │ UInt32 :: Identifier │ │ [<:] │ │ FT :: Identifier │ │ AbstractFace :: Identifier │ │ [<:] │ │ FVT :: Identifier │ │ [curly] │ │ AbstractVector :: Identifier │ │ FT :: Identifier │ │ Names :: Identifier │ │ Dim :: Identifier │ │ T :: Identifier │ │ [<:] │ │ VAT :: Identifier │ │ [curly] │ │ Tuple :: Identifier │ │ [<:] │ │ [curly] │ │ AbstractVector :: Identifier │ │ [curly] │ │ Point :: Identifier │ │ Dim :: Identifier │ │ T :: Identifier │ │ [curly] │ │ Vararg :: Identifier │ │ VertexAttributeType :: Identifier │ │ [block] │ │ [=] │ │ va :: Identifier │ │ vertex_attributes :: Identifier │ │ [=] │ │ names :: Identifier │ │ Names :: Identifier │ │ [if] │ │ [call] │ │ ! :: Identifier │ │ [call] │ │ haskey :: Identifier │ │ va :: Identifier │ │ [inert] │ │ position :: Identifier │ │ [block] │ │ [call] │ │ error :: Identifier │ │ "Vertex attributes must have a :position attribute." :: Value │ │ [if] │ │ [call] │ │ haskey :: Identifier │ │ va :: Identifier │ │ [inert] │ │ normals :: Identifier │ │ [block] │ │ [macrocall] │ │ @warn :: Identifier │ │ :(#= /home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl:533 =#) :: Value │ │ "`normals` as a vertex attribute name has been deprecated in favor of `normal` to bring it in line with mesh.position and mesh.uv" :: Value │ │ [=] │ │ names :: Identifier │ │ [call] │ │ ntuple :: Identifier │ │ [->] │ │ i :: Identifier │ │ [block] │ │ [call] │ │ ifelse :: Identifier │ │ [call] │ │ == :: Identifier │ │ [ref] │ │ names :: Identifier │ │ i :: Identifier │ │ [inert] │ │ normal :: Identifier │ │ [inert] │ │ normal :: Identifier │ │ [ref] │ │ names :: Identifier │ │ i :: Identifier │ │ [call] │ │ length :: Identifier │ │ names :: Identifier │ │ [=] │ │ va :: Identifier │ │ [call] │ │ [curly] │ │ NamedTuple :: Identifier │ │ names :: Identifier │ │ [call] │ │ values :: Identifier │ │ va :: Identifier │ │ [=] │ │ N :: Identifier │ │ [call] │ │ maximum :: Identifier │ │ [->] │ │ f :: Identifier │ │ [block] │ │ [call] │ │ value :: Identifier │ │ [call] │ │ maximum :: Identifier │ │ f :: Identifier │ │ fs :: Identifier │ │ [kw] │ │ init :: Identifier │ │ 0 :: Value │ │ [for] │ │ [=] │ │ [tuple] │ │ name :: Identifier │ │ attrib :: Identifier │ │ [call] │ │ pairs :: Identifier │ │ va :: Identifier │ │ [block] │ │ [if] │ │ [call] │ │ isa :: Identifier │ │ attrib :: Identifier │ │ FaceView :: Identifier │ │ [block] │ │ [try] │ │ [block] │ │ [call] │ │ verify :: Identifier │ │ fs :: Identifier │ │ attrib :: Identifier │ │ e :: Identifier │ │ [block] │ │ [call] │ │ rethrow :: Identifier │ │ [call] │ │ ErrorException :: Identifier │ │ [string] │ │ "Failed to verify " :: Value │ │ name :: Identifier │ │ " attribute:\n" :: Value │ │ [.] │ │ e :: Identifier │ │ [inert] │ │ msg :: Identifier │ │ [block] │ │ [&&] │ │ [call] │ │ < :: Identifier │ │ [call] │ │ length :: Identifier │ │ attrib :: Identifier │ │ N :: Identifier │ │ [call] │ │ error :: Identifier │ │ [string] │ │ "Failed to verify " :: Value │ │ name :: Identifier │ │ " attribute:\nFaces address " :: Value │ │ N :: Identifier │ │ " vertex attributes but only " :: Value │ │ [call] │ │ length :: Identifier │ │ attrib :: Identifier │ │ " are present." :: Value │ │ [return] │ │ [call] │ │ [curly] │ │ new :: Identifier │ │ Dim :: Identifier │ │ T :: Identifier │ │ FT :: Identifier │ │ names :: Identifier │ │ VAT :: Identifier │ │ FVT :: Identifier │ │ va :: Identifier │ │ fs :: Identifier │ │ views :: Identifier │ │ │ st1 = │ SyntaxTree with attributes mod,kind,var_id,toplevel_pure,scope_type,macro_source,name_val,syntax_flags,meta,scope_layer,value,jl_source,is_toplevel_thunk,source │ [block] │ │ [=] │ │ val :: Identifier │ scope_layer=3 │ [struct] │ │ false :: Value │ macro_source=256 │ [<:] │ scope_layer=1 │ [curly] │ │ Mesh :: Identifier │ scope_layer=1 │ Dim :: Identifier │ scope_layer=1 │ [<:] │ scope_layer=1 │ T :: Identifier │ scope_layer=1 │ Real :: Identifier │ scope_layer=1 │ [<:] │ scope_layer=1 │ FT :: Identifier │ scope_layer=1 │ AbstractFace :: Identifier │ scope_layer=1 │ Names :: Identifier │ scope_layer=1 │ [<:] │ scope_layer=1 │ VAT :: Identifier │ scope_layer=1 │ [curly] │ │ Tuple :: Identifier │ scope_layer=1 │ [<:] │ scope_layer=1 │ [curly] │ │ AbstractVector :: Identifier │ scope_layer=1 │ [curly] │ │ Point :: Identifier │ scope_layer=1 │ Dim :: Identifier │ scope_layer=1 │ T :: Identifier │ scope_layer=1 │ [curly] │ │ Vararg :: Identifier │ scope_layer=1 │ VertexAttributeType :: Identifier │ scope_layer=1 │ [<:] │ scope_layer=1 │ FVT :: Identifier │ scope_layer=1 │ [curly] │ │ AbstractVector :: Identifier │ scope_layer=1 │ FT :: Identifier │ scope_layer=1 │ [curly] │ │ AbstractMesh :: Identifier │ scope_layer=1 │ Dim :: Identifier │ scope_layer=1 │ T :: Identifier │ scope_layer=1 │ [block] │ │ [::] │ │ vertex_attributes :: Identifier │ scope_layer=1 │ [curly] │ │ NamedTuple :: Identifier │ scope_layer=1 │ Names :: Identifier │ scope_layer=1 │ VAT :: Identifier │ scope_layer=1 │ [::] │ │ faces :: Identifier │ scope_layer=1 │ FVT :: Identifier │ scope_layer=1 │ [::] │ │ views :: Identifier │ scope_layer=1 │ [curly] │ │ Vector :: Identifier │ scope_layer=1 │ [curly] │ │ UnitRange :: Identifier │ scope_layer=1 │ UInt32 :: Identifier │ scope_layer=1 │ [function] │ │ [where] │ │ [call] │ │ Mesh :: Identifier │ scope_layer=1 │ [::] │ │ vertex_attributes :: Identifier │ scope_layer=1 │ [curly] │ │ NamedTuple :: Identifier │ scope_layer=1 │ Names :: Identifier │ scope_layer=1 │ VAT :: Identifier │ scope_layer=1 │ [::] │ │ fs :: Identifier │ scope_layer=1 │ FVT :: Identifier │ scope_layer=1 │ [kw] │ │ [::] │ │ views :: Identifier │ scope_layer=1 │ [curly] │ │ Vector :: Identifier │ scope_layer=1 │ [<:] │ scope_layer=1 │ [curly] │ │ UnitRange :: Identifier │ scope_layer=1 │ [<:] │ scope_layer=1 │ Integer :: Identifier │ scope_layer=1 │ [ref] │ │ [curly] │ │ UnitRange :: Identifier │ scope_layer=1 │ UInt32 :: Identifier │ scope_layer=1 │ [<:] │ scope_layer=1 │ FT :: Identifier │ scope_layer=1 │ AbstractFace :: Identifier │ scope_layer=1 │ [<:] │ scope_layer=1 │ FVT :: Identifier │ scope_layer=1 │ [curly] │ │ AbstractVector :: Identifier │ scope_layer=1 │ FT :: Identifier │ scope_layer=1 │ Names :: Identifier │ scope_layer=1 │ Dim :: Identifier │ scope_layer=1 │ T :: Identifier │ scope_layer=1 │ [<:] │ scope_layer=1 │ VAT :: Identifier │ scope_layer=1 │ [curly] │ │ Tuple :: Identifier │ scope_layer=1 │ [<:] │ scope_layer=1 │ [curly] │ │ AbstractVector :: Identifier │ scope_layer=1 │ [curly] │ │ Point :: Identifier │ scope_layer=1 │ Dim :: Identifier │ scope_layer=1 │ T :: Identifier │ scope_layer=1 │ [curly] │ │ Vararg :: Identifier │ scope_layer=1 │ VertexAttributeType :: Identifier │ scope_layer=1 │ [block] │ │ [=] │ │ va :: Identifier │ scope_layer=1 │ vertex_attributes :: Identifier │ scope_layer=1 │ [=] │ │ names :: Identifier │ scope_layer=1 │ Names :: Identifier │ scope_layer=1 │ [if] │ │ [call] │ │ ! :: Identifier │ scope_layer=1 │ [call] │ │ haskey :: Identifier │ scope_layer=1 │ va :: Identifier │ scope_layer=1 │ [inert] │ │ position :: Identifier │ │ [block] │ │ [call] │ │ error :: Identifier │ scope_layer=1 │ "Vertex attributes must have a :position attribute." :: Value │ macro_source=256 │ [if] │ │ [call] │ │ haskey :: Identifier │ scope_layer=1 │ va :: Identifier │ scope_layer=1 │ [inert] │ │ normals :: Identifier │ │ [block] │ │ [block] │ │ [let] │ │ [block] │ macro_source=256 │ [block] │ │ [=] │ │ #7#level :: Identifier │ scope_layer=1 │ Warn :: Identifier │ mod,scope_layer=1 │ [=] │ │ #8#std_level :: Identifier │ scope_layer=1 │ #7#level :: Identifier │ scope_layer=1 │ [if] │ │ [call] │ │ >= :: Identifier │ mod,scope_layer=1 │ [.] │ │ #8#std_level :: Identifier │ scope_layer=1 │ [inert] │ │ level :: Identifier │ │ [ref] │ macro_source=256 │ Base.Threads.Atomic{Int32}(-1000) :: Value │ macro_source=256 │ [block] │ │ [=] │ │ #9#group :: Identifier │ scope_layer=1 │ [inert] │ │ basic_types :: Identifier │ │ [=] │ │ #10#_module :: Identifier │ scope_layer=1 │ GeometryBasics :: Value │ macro_source=256 │ [=] │ │ #11#logger :: Identifier │ scope_layer=1 │ [call] │ │ Base.CoreLogging.current_logger_for_env :: Value │ macro_source=256 │ #8#std_level :: Identifier │ scope_layer=1 │ #9#group :: Identifier │ scope_layer=1 │ #10#_module :: Identifier │ scope_layer=1 │ [if] │ │ [call] │ │ ! :: Identifier │ mod,scope_layer=1 │ [call] │ │ === :: Identifier │ mod,scope_layer=1 │ #11#logger :: Identifier │ scope_layer=1 │ nothing :: Identifier │ mod,scope_layer=1 │ [block] │ │ [=] │ │ #12#id :: Identifier │ scope_layer=1 │ [inert] │ │ GeometryBasics_1e57c75a :: Identifier │ │ [if] │ │ [call] │ │ invokelatest :: Identifier │ mod,scope_layer=1 │ Base.CoreLogging.shouldlog :: Value │ macro_source=256 │ #11#logger :: Identifier │ scope_layer=1 │ #7#level :: Identifier │ scope_layer=1 │ #10#_module :: Identifier │ scope_layer=1 │ #9#group :: Identifier │ scope_layer=1 │ #12#id :: Identifier │ scope_layer=1 │ [block] │ │ [=] │ │ #13#file :: Identifier │ scope_layer=1 │ "/home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl" :: Value │ macro_source=256 │ [if] │ │ [call] │ │ isa :: Identifier │ mod,scope_layer=1 │ #13#file :: Identifier │ scope_layer=1 │ String :: Identifier │ mod,scope_layer=1 │ [block] │ │ [=] │ │ #13#file :: Identifier │ scope_layer=1 │ [call] │ │ [.] │ │ Base :: Identifier │ mod,scope_layer=1 │ [inert] │ │ fixup_stdlib_path :: Identifier │ │ #13#file :: Identifier │ scope_layer=1 │ [=] │ │ #14#line :: Identifier │ scope_layer=1 │ 533 :: Value │ macro_source=256 │ [local] │ │ #15#msg :: Identifier │ scope_layer=1 │ #16#kwargs :: Identifier │ scope_layer=1 │ [if] │ │ [block] │ │ [=] │ │ #15#msg :: Identifier │ scope_layer=1 │ "`normals` as a vertex attribute name has been deprecated in favor of `normal` to bring it in line with mesh.position and mesh.uv" :: Value │ macro_source=256 │ [=] │ │ #16#kwargs :: Identifier │ scope_layer=1 │ [tuple] │ macro_source=256 │ [parameters] │ macro_source=256 │ true :: Value │ macro_source=256 │ [block] │ │ [if] │ │ [isdefined] │ │ #15#msg :: Identifier │ scope_layer=1 │ nothing :: Value │ macro_source=256 │ [call] │ │ throw :: Identifier │ mod,scope_layer=1 │ [call] │ │ AssertionError :: Identifier │ mod,scope_layer=1 │ "Assertion to tell the compiler about the definedness of this variable" :: Value │ macro_source=256 │ [if] │ │ [isdefined] │ │ #16#kwargs :: Identifier │ scope_layer=1 │ nothing :: Value │ macro_source=256 │ [call] │ │ throw :: Identifier │ mod,scope_layer=1 │ [call] │ │ AssertionError :: Identifier │ mod,scope_layer=1 │ "Assertion to tell the compiler about the definedness of this variable" :: Value │ macro_source=256 │ [call] │ │ Base.CoreLogging.handle_message_nothrow :: Value │ macro_source=256 │ [parameters] │ │ [...] │ │ #16#kwargs :: Identifier │ scope_layer=1 │ #11#logger :: Identifier │ scope_layer=1 │ #7#level :: Identifier │ scope_layer=1 │ #15#msg :: Identifier │ scope_layer=1 │ #10#_module :: Identifier │ scope_layer=1 │ #9#group :: Identifier │ scope_layer=1 │ #12#id :: Identifier │ scope_layer=1 │ #13#file :: Identifier │ scope_layer=1 │ #14#line :: Identifier │ scope_layer=1 │ nothing :: Identifier │ mod,scope_layer=1 │ [=] │ │ names :: Identifier │ scope_layer=1 │ [call] │ │ ntuple :: Identifier │ scope_layer=1 │ [->] │ │ i :: Identifier │ scope_layer=1 │ [block] │ │ [call] │ │ ifelse :: Identifier │ scope_layer=1 │ [call] │ │ == :: Identifier │ scope_layer=1 │ [ref] │ │ names :: Identifier │ scope_layer=1 │ i :: Identifier │ scope_layer=1 │ [inert] │ │ normal :: Identifier │ │ [inert] │ │ normal :: Identifier │ │ [ref] │ │ names :: Identifier │ scope_layer=1 │ i :: Identifier │ scope_layer=1 │ [call] │ │ length :: Identifier │ scope_layer=1 │ names :: Identifier │ scope_layer=1 │ [=] │ │ va :: Identifier │ scope_layer=1 │ [call] │ │ [curly] │ │ NamedTuple :: Identifier │ scope_layer=1 │ names :: Identifier │ scope_layer=1 │ [call] │ │ values :: Identifier │ scope_layer=1 │ va :: Identifier │ scope_layer=1 │ [=] │ │ N :: Identifier │ scope_layer=1 │ [call] │ │ maximum :: Identifier │ scope_layer=1 │ [->] │ │ f :: Identifier │ scope_layer=1 │ [block] │ │ [call] │ │ value :: Identifier │ scope_layer=1 │ [call] │ │ maximum :: Identifier │ scope_layer=1 │ f :: Identifier │ scope_layer=1 │ fs :: Identifier │ scope_layer=1 │ [kw] │ │ init :: Identifier │ scope_layer=1 │ 0 :: Value │ macro_source=256 │ [for] │ │ [=] │ │ [tuple] │ │ name :: Identifier │ scope_layer=1 │ attrib :: Identifier │ scope_layer=1 │ [call] │ │ pairs :: Identifier │ scope_layer=1 │ va :: Identifier │ scope_layer=1 │ [block] │ │ [if] │ │ [call] │ │ isa :: Identifier │ scope_layer=1 │ attrib :: Identifier │ scope_layer=1 │ FaceView :: Identifier │ scope_layer=1 │ [block] │ │ [try] │ │ [block] │ │ [call] │ │ verify :: Identifier │ scope_layer=1 │ fs :: Identifier │ scope_layer=1 │ attrib :: Identifier │ scope_layer=1 │ e :: Identifier │ scope_layer=1 │ [block] │ │ [call] │ │ rethrow :: Identifier │ scope_layer=1 │ [call] │ │ ErrorException :: Identifier │ scope_layer=1 │ [string] │ │ "Failed to verify " :: Value │ macro_source=256 │ name :: Identifier │ scope_layer=1 │ " attribute:\n" :: Value │ macro_source=256 │ [.] │ │ e :: Identifier │ scope_layer=1 │ [inert] │ │ msg :: Identifier │ │ [block] │ │ [&&] │ │ [call] │ │ < :: Identifier │ scope_layer=1 │ [call] │ │ length :: Identifier │ scope_layer=1 │ attrib :: Identifier │ scope_layer=1 │ N :: Identifier │ scope_layer=1 │ [call] │ │ error :: Identifier │ scope_layer=1 │ [string] │ │ "Failed to verify " :: Value │ macro_source=256 │ name :: Identifier │ scope_layer=1 │ " attribute:\nFaces address " :: Value │ macro_source=256 │ N :: Identifier │ scope_layer=1 │ " vertex attributes but only " :: Value │ macro_source=256 │ [call] │ │ length :: Identifier │ scope_layer=1 │ attrib :: Identifier │ scope_layer=1 │ " are present." :: Value │ macro_source=256 │ [return] │ │ [call] │ │ [curly] │ │ new :: Identifier │ scope_layer=1 │ Dim :: Identifier │ scope_layer=1 │ T :: Identifier │ scope_layer=1 │ FT :: Identifier │ scope_layer=1 │ names :: Identifier │ scope_layer=1 │ VAT :: Identifier │ scope_layer=1 │ FVT :: Identifier │ scope_layer=1 │ va :: Identifier │ scope_layer=1 │ fs :: Identifier │ scope_layer=1 │ views :: Identifier │ scope_layer=1 │ [call] │ │ Base.Docs.doc! :: Value │ macro_source=256 │ GeometryBasics :: Value │ macro_source=256 │ [call] │ │ Base.Docs.Binding :: Value │ macro_source=256 │ GeometryBasics :: Value │ │ [inert] │ jl_source=L65 │ Mesh :: Identifier │ │ [call] │ │ Base.Docs.docstr :: Value │ macro_source=256 │ [call] │ macro_source=256 │ Core.svec :: Value │ macro_source=256 │ " Mesh{PositionDim, PositionType, FaceType, VertexAttributeNames, VertexAttributeTypes, FaceVectorType} <: AbstractMesh{PositionDim, PositionType} <: AbstractGeometry{PositionDim, PositionType}\n\nThe type of a concrete mesh. The associated struct contains 3 fields:\n\n```julia\nstruct Mesh{...}\n vertex_attributes::NamedTuple{VertexAttributeNames, VertexAttributeTypes}\n faces::FaceVectorType\n views::Vector{UnitRange{Int}}\nend\n```\n\nA vertex typically carries multiple distinct pieces of data, e.g. a position,\na normal, a texture coordinate, etc. We call those pieces of data vertex\nattributes. The `vertex_attributes` field contains the name and a collection\n`<: AbstractVector` or `<: FaceView` for each attribute. The n-th element of that\ncollection is the value of the corresponding attribute for the n-th vertex.\n\n```julia\n# vertex 1 2 3\nvertex_attributes[:position] = [pos1, pos2, pos3, ...]\nvertex_attributes[:normal] = [normal1, normal2, normal3, ...]\n...\n```\n\nA `NamedTuple` is used here to allow different meshes to carry different vertex\nattributes while also keeping things type stable. The constructor enforces a\nfew restrictions:\n- The first attribute must be named `position` and must have a `Point{PositionDim, PositionType}` eltype.\n- Each vertex attribute must refer to the same number of vertices. (All vertex attributes defined by\nAbstractVector must match in length. For FaceViews, the number of faces needs to match.)\n\nSee also: [`vertex_attributes`](@ref), [`coordinates`](@ref), [`normals`](@ref),\n[`texturecoordinates`](@ref), [`decompose`](@ref), [`FaceView`](@ref),\n[`expand_faceviews`](@ref)\n\nThe `faces` field is a collection `<: AbstractVector{FaceType}` containing faces\nthat describe how vertices are connected. Typically these are `(GL)TriangleFace`s\nor `QuadFace`s, but they can be any collection of vertex indices `<: AbstractFace`.\n\nSee also: [`faces`](@ref), [`decompose`](@ref)\n\nThe `views` field can be used to separate the mesh into mutliple submeshes. Each\nsubmesh is described by a \"view\" into the `faces` vector, i.e. submesh n uses\n`mesh.faces[mesh.views[n]]`. A `Mesh` can be constructed without `views`, which\nresults in an empty `views` vector.\n\nSee also: [`merge`](@ref), [`split_mesh`](@ref)\n" :: Value │ macro_source=256 │ [call] │ │ Dict{Symbol, Any} :: Value │ macro_source=256 │ :path => "/home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl" :: Value │ macro_source=256 │ :linenumber => 453 :: Value │ macro_source=256 │ :module => GeometryBasics :: Value │ macro_source=256 │ [call] │ │ Pair :: Value │ macro_source=256 │ [inert] │ │ fields :: Identifier │ │ [call] │ macro_source=256 │ Dict{Symbol, Any} :: Value │ macro_source=256 │ [curly] │ │ Union :: Identifier │ scope_layer=1 │ val :: Identifier │ scope_layer=3 │ │ file = "/home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl" │ line = 453 └ mod = GeometryBasics ERROR: LoadError: internal lowering bug: #= /home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl:515 =# - `jl_assert(!(haskey(ssa_rewrites, lhs_id)), _)`: multiple assignments to ssavalue Expression:  (= #₂₆ (call core.TypeVar :#T1 #₂₈₉)) Containing expressions:  (= #₂₆ (call core.TypeVar :#T1 #₂₈₉))  Detailed provenance:  (= #₂₆ (call core.TypeVar :#T1 #₂₈₉)) @#= /source/usr/share/julia/JuliaLowering/src/linear_ir.jl:366 =#  └─ (= #₂₆ (call core.TypeVar :#T1 (call core.apply_type #₅₆/AbstractVector (call core.apply_type #₅₇/Point #₆₉/Dim #₇₀/T)))) @#= /source/usr/share/julia/JuliaLowering/src/closure_conversion.jl:197 =#  └─ (= #₂₆ (call core.TypeVar :#T1 (call core.apply_type #₅₆/AbstractVector (call core.apply_type #₅₇/Point #₆₉/Dim #₇₀/T)))) @#= /source/usr/share/julia/JuliaLowering/src/desugaring.jl:231 =#  └─ (= #₂₆ (call core.TypeVar :#T1 (call core.apply_type AbstractVector (call core.apply_type Point Dim T)))) @#= /source/usr/share/julia/JuliaLowering/src/desugaring.jl:231 =#  └─ (= #₂₆ (call core.TypeVar :#T1 (curly AbstractVector (curly Point Dim T))))  └─ (call core.TypeVar :#T1 (curly AbstractVector (curly Point Dim T))) @#= /source/usr/share/julia/JuliaLowering/src/desugaring.jl:3025 =#  └─ (<: (curly AbstractVector (curly Point Dim T)))  └─ (<: (curly AbstractVector (curly Point Dim T)))  └─ (<: (curly AbstractVector (curly Point Dim T)))  └─ (<: (curly AbstractVector (curly Point Dim T)))  ├─ @ /home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl:515  └─ (macrocall @doc :(#= /home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl:453 =#) " Mesh{PositionDim, PositionType, FaceType, VertexAttributeNames, VertexAttributeTypes, FaceVectorType} <: AbstractMesh{PositionDim, PositionType} <: AbstractGeometry{PositionDim, PositionType}\n\nThe type of a concrete mesh. The associated struct contains 3 fields:\n\n```julia\nstruct Mesh{...}\n vertex_attributes::NamedTuple{VertexAttributeNames, VertexAttributeTypes}\n faces::FaceVectorType\n views::Vector{UnitRange{Int}}\nend\n```\n\nA vertex typically carries multiple distinct pieces of data, e.g. a position,\na normal, a texture coordinate, etc. We call those pieces of data vertex\nattributes. The `vertex_attributes` field contains the name and a collection\n`<: AbstractVector` or `<: FaceView` for each attribute. The n-th element of that\ncollection is the value of the corresponding attribute for the n-th vertex.\n\n```julia\n# vertex 1 2 3\nvertex_attributes[:position] = [pos1, pos2, pos3, ...]\nvertex_attributes[:normal] = [normal1, normal2, normal3, ...]\n...\n```\n\nA `NamedTuple` is used here to allow different meshes to carry different vertex\nattributes while also keeping things type stable. The constructor enforces a\nfew restrictions:\n- The first attribute must be named `position` and must have a `Point{PositionDim, PositionType}` eltype.\n- Each vertex attribute must refer to the same number of vertices. (All vertex attributes defined by\nAbstractVector must match in length. For FaceViews, the number of faces needs to match.)\n\nSee also: [`vertex_attributes`](@ref), [`coordinates`](@ref), [`normals`](@ref),\n[`texturecoordinates`](@ref), [`decompose`](@ref), [`FaceView`](@ref),\n[`expand_faceviews`](@ref)\n\nThe `faces` field is a collection `<: AbstractVector{FaceType}` containing faces\nthat describe how vertices are connected. Typically these are `(GL)TriangleFace`s\nor `QuadFace`s, but they can be any collection of vertex indices `<: AbstractFace`.\n\nSee also: [`faces`](@ref), [`decompose`](@ref)\n\nThe `views` field can be used to separate the mesh into mutliple submeshes. Each\nsubmesh is described by a \"view\" into the `faces` vector, i.e. submesh n uses\n`mesh.faces[mesh.views[n]]`. A `Mesh` can be constructed without `views`, which\nresults in an empty `views` vector.\n\nSee also: [`merge`](@ref), [`split_mesh`](@ref)\n" (struct false (<: (curly Mesh Dim (<: T Real) (<: FT AbstractFace) Names (<: VAT (curly Tuple (<: (curly AbstractVector (curly Point Dim T))) (curly Vararg VertexAttributeType))) (<: FVT (curly AbstractVector FT))) (curly AbstractMesh Dim T)) (block (:: vertex_attributes (curly NamedTuple Names VAT)) (:: faces FVT) (:: views (curly Vector (curly UnitRange UInt32))) (function (where (call Mesh (:: vertex_attributes (curly NamedTuple Names VAT)) (:: fs FVT) (kw (:: views (curly Vector (<: (curly UnitRange (<: Integer))))) (ref (curly UnitRange UInt32)))) (<: FT AbstractFace) (<: FVT (curly AbstractVector FT)) Names Dim T (<: VAT (curly Tuple (<: (curly AbstractVector (curly Point Dim T))) (curly Vararg VertexAttributeType)))) (block (= va vertex_attributes) (= names Names) (if (call ! (call haskey va (inert position))) (block (call error "Vertex attributes must have a :position attribute."))) (if (call haskey va (inert normals)) (block (macrocall @warn :(#= /home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl:533 =#) "`normals` as a vertex attribute name has been deprecated in favor of `normal` to bring it in line with mesh.position and mesh.uv") (= names (call ntuple (-> i (block (call ifelse (call == (ref names i) (inert normal)) (inert normal) (ref names i)))) (call length names))) (= va (call (curly NamedTuple names) (call values va))))) (= N (call maximum (-> f (block (call value (call maximum f)))) fs (kw init 0))) (for (= (tuple name attrib) (call pairs va)) (block (if (call isa attrib FaceView) (block (try (block (call verify fs attrib)) e (block (call rethrow (call ErrorException (string "Failed to verify " name " attribute:\n" (. e (inert msg)))))))) (block (&& (call < (call length attrib) N) (call error (string "Failed to verify " name " attribute:\nFaces address " N " vertex attributes but only " (call length attrib) " are present."))))))) (return (call (curly new Dim T FT names VAT FVT) va fs views)))))))  └─ @ /home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl:453  Stacktrace:  [1] iterate(A::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, Vector{Int64}})  @ Base /source/usr/share/julia/JuliaLowering/src/ast.jl:23 [inlined]  [2] renumber_body(ctx::Base.JuliaLowering.LinearIRContext{Dict{Symbol, Dict{Int64, Any}}}, input_code::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, Vector{Int64}}, slot_rewrites::Dict{Int64, Int64})  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/linear_ir.jl:1106  [3] compile_lambda(outer_ctx::Base.JuliaLowering.LinearIRContext{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}})  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/linear_ir.jl:1223  [4] linearize_ir(ctx::Base.JuliaLowering.ClosureConversionCtx{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}})  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/linear_ir.jl:1253  [5] core_lowering_hook(code::Any, mod::Module, file::String, line::UInt64, world::UInt64, _warn::Bool)  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/hooks.jl:33  [6] include(mapexpr::Function, mod::Module, _path::String)  @ Base ./Base.jl:327  [7] top-level scope  @ ~/.julia/packages/GeometryBasics/yB1f1/src/GeometryBasics.jl:12  [8] include(mod::Module, _path::String)  @ Base ./Base.jl:326  [9] 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  [10] top-level scope  @ stdin:5  [11] eval(m::Module, e::Any)  @ Core ./boot.jl:517  [12] include_string(mapexpr::typeof(identity), mod::Module, code::String, filename::String)  @ Base ./loading.jl:3113  [13] push!(a::Vector{SubString{String}}, item::String)  @ Base ./loading.jl:3123 [inlined]  [14] exec_options(opts::Base.JLOptions)  @ Base ./client.jl:353  [15] _start()  @ Base ./client.jl:596 in expression starting at /home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl:453 in expression starting at /home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/GeometryBasics.jl:1 in expression starting at stdin:5 ✗ GeometryBasics 22.2 s ✓ JSON3 ERROR: LoadError: Precompiled image Base.PkgId(Base.UUID("5c1252a2-5f33-56bf-86c9-59e7332b4326"), "GeometryBasics") 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/GeometryBasics/yB1f1/ext/GeometryBasicsGeoInterfaceExt.jl:3  [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/GeometryBasics/yB1f1/ext/GeometryBasicsGeoInterfaceExt.jl:1 in expression starting at stdin:5 ✗ GeometryBasics → GeometryBasicsGeoInterfaceExt 123.5 s ✓ GeoJSON 24 dependencies successfully precompiled in 1863 seconds. 31 already precompiled. Precompilation completed after 1890.33s ################################################################################ # Testing # Testing GeometryBasics Status `/tmp/jl_kVOkRa/Project.toml` [4c88cf16] Aqua v0.8.14 [411431e0] Extents v0.1.6 [cf35fbd7] GeoInterface v1.6.1 [61d90e0f] GeoJSON v0.8.4 [5c1252a2] GeometryBasics v0.5.10 [c8e1da08] IterTools v1.10.0 [6fe1bfb0] OffsetArrays v1.17.0 [aea7be01] PrecompileTools v1.3.4 [90137ffa] StaticArrays v1.9.18 [5ae413db] EarCut_jll v2.2.4+0 [37e2e46d] LinearAlgebra v1.13.0 [9a3f8284] Random v1.11.0 [8dfed614] Test v1.11.0 Status `/tmp/jl_kVOkRa/Manifest.toml` [4c88cf16] Aqua v0.8.14 [34da2185] Compat v4.18.1 [9a962f9c] DataAPI v1.16.0 [e2d170a0] DataValueInterfaces v1.0.0 [411431e0] Extents v0.1.6 [68eda718] GeoFormatTypes v0.4.5 [cf35fbd7] GeoInterface v1.6.1 [61d90e0f] GeoJSON v0.8.4 [5c1252a2] GeometryBasics v0.5.10 [c8e1da08] IterTools v1.10.0 [82899510] IteratorInterfaceExtensions v1.0.0 [692b3bcd] JLLWrappers v1.8.0 [0f8b85d8] JSON3 v1.14.3 [6fe1bfb0] OffsetArrays v1.17.0 [bac558e1] OrderedCollections v1.8.1 [69de0a69] Parsers v2.8.4 [aea7be01] PrecompileTools v1.3.4 [21216c6a] Preferences v1.5.2 [90137ffa] StaticArrays v1.9.18 [1e83bf80] StaticArraysCore v1.4.4 [856f2bd8] StructTypes v1.11.0 [3783bdb8] TableTraits v1.0.1 [bd369af6] Tables v1.12.1 [5ae413db] EarCut_jll v2.2.4+0 [0dad84c5] ArgTools v1.1.2 [56f22d72] Artifacts v1.11.0 [2a0f44e3] Base64 v1.11.0 [ade2ca70] Dates v1.11.0 [f43a241f] Downloads v1.7.0 [7b1f6079] FileWatching v1.11.0 [b77e0a4c] InteractiveUtils v1.11.0 [ac6e5ff7] JuliaSyntaxHighlighting v1.13.0 [b27032c2] LibCURL v1.0.0 [76f85450] LibGit2 v1.11.0 [8f399da3] Libdl v1.11.0 [37e2e46d] LinearAlgebra v1.13.0 [56ddb016] Logging v1.11.0 [d6f4376e] Markdown v1.11.0 [a63ad114] Mmap v1.11.0 [ca575930] NetworkOptions v1.3.0 [44cfe95a] Pkg v1.14.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 [a4e569a6] Tar v1.10.0 [8dfed614] Test v1.11.0 [cf7118a7] UUIDs v1.11.0 [4ec0a83e] Unicode v1.11.0 [e66e0078] CompilerSupportLibraries_jll v1.5.1+0 [deac9b47] LibCURL_jll v8.20.0+1 [e37daf67] LibGit2_jll v1.9.3+0 [29816b5a] LibSSH2_jll v1.11.101+0 [14a3606d] MozillaCACerts_jll v2026.5.14 [4536629a] OpenBLAS_jll v0.3.33+0 [458c3c95] OpenSSL_jll v3.5.6+0 [efcefdf7] PCRE2_jll v10.47.0+0 [83775a58] Zlib_jll v1.3.2+0 [3161d3a3] Zstd_jll v1.5.7+1 [8e850b90] libblastrampoline_jll v5.15.0+0 [8e850ede] nghttp2_jll v1.69.0+0 [3f19e933] p7zip_jll v17.8.0+0 Testing Running tests... ┌ Info: JuliaLowering threw given input: │ code = │ :(#= /home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl:453 =# Core.@doc " Mesh{PositionDim, PositionType, FaceType, VertexAttributeNames, VertexAttributeTypes, FaceVectorType} <: AbstractMesh{PositionDim, PositionType} <: AbstractGeometry{PositionDim, PositionType}\n\nThe type of a concrete mesh. The associated struct contains 3 fields:\n\n```julia\nstruct Mesh{...}\n vertex_attributes::NamedTuple{VertexAttributeNames, VertexAttributeTypes}\n faces::FaceVectorType\n views::Vector{UnitRange{Int}}\nend\n```\n\nA vertex typically carries multiple distinct pieces of data, e.g. a position,\na normal, a texture coordinate, etc. We call those pieces of data vertex\nattributes. The `vertex_attributes` field contains the name and a collection\n`<: AbstractVector` or `<: FaceView` for each attribute. The n-th element of that\ncollection is the value of the corresponding attribute for the n-th vertex.\n\n```julia\n# vertex 1 2 3\nvertex_attributes[:position] = [pos1, pos2, pos3, ...]\nvertex_attributes[:normal] = [normal1, normal2, normal3, ...]\n...\n```\n\nA `NamedTuple` is used here to allow different meshes to carry different vertex\nattributes while also keeping things type stable. The constructor enforces a\nfew restrictions:\n- The first attribute must be named `position` and must have a `Point{PositionDim, PositionType}` eltype.\n- Each vertex attribute must refer to the same number of vertices. (All vertex attributes defined by\nAbstractVector must match in length. For FaceViews, the number of faces needs to match.)\n\nSee also: [`vertex_attributes`](@ref), [`coordinates`](@ref), [`normals`](@ref),\n[`texturecoordinates`](@ref), [`decompose`](@ref), [`FaceView`](@ref),\n[`expand_faceviews`](@ref)\n\nThe `faces` field is a collection `<: AbstractVector{FaceType}` containing faces\nthat describe how vertices are connected. Typically these are `(GL)TriangleFace`s\nor `QuadFace`s, but they can be any collection of vertex indices `<: AbstractFace`.\n\nSee also: [`faces`](@ref), [`decompose`](@ref)\n\nThe `views` field can be used to separate the mesh into mutliple submeshes. Each\nsubmesh is described by a \"view\" into the `faces` vector, i.e. submesh n uses\n`mesh.faces[mesh.views[n]]`. A `Mesh` can be constructed without `views`, which\nresults in an empty `views` vector.\n\nSee also: [`merge`](@ref), [`split_mesh`](@ref)\n" struct Mesh{Dim, T <: Real, FT <: AbstractFace, Names, VAT <: Tuple{<:AbstractVector{Point{Dim, T}}, Vararg{VertexAttributeType}}, FVT <: AbstractVector{FT}} <: AbstractMesh{Dim, T} │ #= /home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl:511 =# │ vertex_attributes::NamedTuple{Names, VAT} │ #= /home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl:512 =# │ faces::FVT │ #= /home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl:513 =# │ views::Vector{UnitRange{UInt32}} │ #= /home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl:515 =# │ function Mesh(vertex_attributes::NamedTuple{Names, VAT}, fs::FVT, views::Vector{<:UnitRange{<:Integer}} = UnitRange{UInt32}[]) where {FT <: AbstractFace, FVT <: AbstractVector{FT}, Names, Dim, T, VAT <: Tuple{<:AbstractVector{Point{Dim, T}}, Vararg{VertexAttributeType}}} │ #= /home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl:515 =# │ #= /home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl:524 =# │ va = vertex_attributes │ #= /home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl:525 =# │ names = Names │ #= /home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl:528 =# │ if !(haskey(va, :position)) │ #= /home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl:529 =# │ error("Vertex attributes must have a :position attribute.") │ end │ #= /home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl:532 =# │ if haskey(va, :normals) │ #= /home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl:533 =# │ #= /home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl:533 =# @warn "`normals` as a vertex attribute name has been deprecated in favor of `normal` to bring it in line with mesh.position and mesh.uv" │ #= /home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl:534 =# │ names = ntuple((i->begin │ #= /home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl:534 =# │ ifelse(names[i] == :normal, :normal, names[i]) │ end), length(names)) │ #= /home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl:535 =# │ va = NamedTuple{names}(values(va)) │ end │ #= /home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl:541 =# │ N = maximum((f->begin │ #= /home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl:541 =# │ value(maximum(f)) │ end), fs, init = 0) │ #= /home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl:542 =# │ for (name, attrib) = pairs(va) │ #= /home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl:543 =# │ if attrib isa FaceView │ #= /home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl:544 =# │ try │ #= /home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl:545 =# │ verify(fs, attrib) │ catch e │ #= /home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl:547 =# │ rethrow(ErrorException("Failed to verify $(name) attribute:\n$(e.msg)")) │ end │ else │ #= /home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl:550 =# │ length(attrib) < N && error("Failed to verify $(name) attribute:\nFaces address $(N) vertex attributes but only $(length(attrib)) are present.") │ end │ #= /home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl:552 =# │ end │ #= /home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl:554 =# │ return new{Dim, T, FT, names, VAT, FVT}(va, fs, views) │ end │ end) │ st0 = │ SyntaxTree with attributes mod,kind,var_id,toplevel_pure,scope_type,macro_source,name_val,syntax_flags,meta,scope_layer,value,jl_source,is_toplevel_thunk,source,__macro_ctx__ │ [macrocall] │ │ @doc :: Identifier │ mod │ :(#= /home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl:453 =#) :: Value │ │ " Mesh{PositionDim, PositionType, FaceType, VertexAttributeNames, VertexAttributeTypes, FaceVectorType} <: AbstractMesh{PositionDim, PositionType} <: AbstractGeometry{PositionDim, PositionType}\n\nThe type of a concrete mesh. The associated struct contains 3 fields:\n\n```julia\nstruct Mesh{...}\n vertex_attributes::NamedTuple{VertexAttributeNames, VertexAttributeTypes}\n faces::FaceVectorType\n views::Vector{UnitRange{Int}}\nend\n```\n\nA vertex typically carries multiple distinct pieces of data, e.g. a position,\na normal, a texture coordinate, etc. We call those pieces of data vertex\nattributes. The `vertex_attributes` field contains the name and a collection\n`<: AbstractVector` or `<: FaceView` for each attribute. The n-th element of that\ncollection is the value of the corresponding attribute for the n-th vertex.\n\n```julia\n# vertex 1 2 3\nvertex_attributes[:position] = [pos1, pos2, pos3, ...]\nvertex_attributes[:normal] = [normal1, normal2, normal3, ...]\n...\n```\n\nA `NamedTuple` is used here to allow different meshes to carry different vertex\nattributes while also keeping things type stable. The constructor enforces a\nfew restrictions:\n- The first attribute must be named `position` and must have a `Point{PositionDim, PositionType}` eltype.\n- Each vertex attribute must refer to the same number of vertices. (All vertex attributes defined by\nAbstractVector must match in length. For FaceViews, the number of faces needs to match.)\n\nSee also: [`vertex_attributes`](@ref), [`coordinates`](@ref), [`normals`](@ref),\n[`texturecoordinates`](@ref), [`decompose`](@ref), [`FaceView`](@ref),\n[`expand_faceviews`](@ref)\n\nThe `faces` field is a collection `<: AbstractVector{FaceType}` containing faces\nthat describe how vertices are connected. Typically these are `(GL)TriangleFace`s\nor `QuadFace`s, but they can be any collection of vertex indices `<: AbstractFace`.\n\nSee also: [`faces`](@ref), [`decompose`](@ref)\n\nThe `views` field can be used to separate the mesh into mutliple submeshes. Each\nsubmesh is described by a \"view\" into the `faces` vector, i.e. submesh n uses\n`mesh.faces[mesh.views[n]]`. A `Mesh` can be constructed without `views`, which\nresults in an empty `views` vector.\n\nSee also: [`merge`](@ref), [`split_mesh`](@ref)\n" :: Value │ │ [struct] │ │ false :: Value │ │ [<:] │ │ [curly] │ │ Mesh :: Identifier │ │ Dim :: Identifier │ │ [<:] │ │ T :: Identifier │ │ Real :: Identifier │ │ [<:] │ │ FT :: Identifier │ │ AbstractFace :: Identifier │ │ Names :: Identifier │ │ [<:] │ │ VAT :: Identifier │ │ [curly] │ │ Tuple :: Identifier │ │ [<:] │ │ [curly] │ │ AbstractVector :: Identifier │ │ [curly] │ │ Point :: Identifier │ │ Dim :: Identifier │ │ T :: Identifier │ │ [curly] │ │ Vararg :: Identifier │ │ VertexAttributeType :: Identifier │ │ [<:] │ │ FVT :: Identifier │ │ [curly] │ │ AbstractVector :: Identifier │ │ FT :: Identifier │ │ [curly] │ │ AbstractMesh :: Identifier │ │ Dim :: Identifier │ │ T :: Identifier │ │ [block] │ │ [::] │ │ vertex_attributes :: Identifier │ │ [curly] │ │ NamedTuple :: Identifier │ │ Names :: Identifier │ │ VAT :: Identifier │ │ [::] │ │ faces :: Identifier │ │ FVT :: Identifier │ │ [::] │ │ views :: Identifier │ │ [curly] │ │ Vector :: Identifier │ │ [curly] │ │ UnitRange :: Identifier │ │ UInt32 :: Identifier │ │ [function] │ │ [where] │ │ [call] │ │ Mesh :: Identifier │ │ [::] │ │ vertex_attributes :: Identifier │ │ [curly] │ │ NamedTuple :: Identifier │ │ Names :: Identifier │ │ VAT :: Identifier │ │ [::] │ │ fs :: Identifier │ │ FVT :: Identifier │ │ [kw] │ │ [::] │ │ views :: Identifier │ │ [curly] │ │ Vector :: Identifier │ │ [<:] │ │ [curly] │ │ UnitRange :: Identifier │ │ [<:] │ │ Integer :: Identifier │ │ [ref] │ │ [curly] │ │ UnitRange :: Identifier │ │ UInt32 :: Identifier │ │ [<:] │ │ FT :: Identifier │ │ AbstractFace :: Identifier │ │ [<:] │ │ FVT :: Identifier │ │ [curly] │ │ AbstractVector :: Identifier │ │ FT :: Identifier │ │ Names :: Identifier │ │ Dim :: Identifier │ │ T :: Identifier │ │ [<:] │ │ VAT :: Identifier │ │ [curly] │ │ Tuple :: Identifier │ │ [<:] │ │ [curly] │ │ AbstractVector :: Identifier │ │ [curly] │ │ Point :: Identifier │ │ Dim :: Identifier │ │ T :: Identifier │ │ [curly] │ │ Vararg :: Identifier │ │ VertexAttributeType :: Identifier │ │ [block] │ │ [=] │ │ va :: Identifier │ │ vertex_attributes :: Identifier │ │ [=] │ │ names :: Identifier │ │ Names :: Identifier │ │ [if] │ │ [call] │ │ ! :: Identifier │ │ [call] │ │ haskey :: Identifier │ │ va :: Identifier │ │ [inert] │ │ position :: Identifier │ │ [block] │ │ [call] │ │ error :: Identifier │ │ "Vertex attributes must have a :position attribute." :: Value │ │ [if] │ │ [call] │ │ haskey :: Identifier │ │ va :: Identifier │ │ [inert] │ │ normals :: Identifier │ │ [block] │ │ [macrocall] │ │ @warn :: Identifier │ │ :(#= /home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl:533 =#) :: Value │ │ "`normals` as a vertex attribute name has been deprecated in favor of `normal` to bring it in line with mesh.position and mesh.uv" :: Value │ │ [=] │ │ names :: Identifier │ │ [call] │ │ ntuple :: Identifier │ │ [->] │ │ i :: Identifier │ │ [block] │ │ [call] │ │ ifelse :: Identifier │ │ [call] │ │ == :: Identifier │ │ [ref] │ │ names :: Identifier │ │ i :: Identifier │ │ [inert] │ │ normal :: Identifier │ │ [inert] │ │ normal :: Identifier │ │ [ref] │ │ names :: Identifier │ │ i :: Identifier │ │ [call] │ │ length :: Identifier │ │ names :: Identifier │ │ [=] │ │ va :: Identifier │ │ [call] │ │ [curly] │ │ NamedTuple :: Identifier │ │ names :: Identifier │ │ [call] │ │ values :: Identifier │ │ va :: Identifier │ │ [=] │ │ N :: Identifier │ │ [call] │ │ maximum :: Identifier │ │ [->] │ │ f :: Identifier │ │ [block] │ │ [call] │ │ value :: Identifier │ │ [call] │ │ maximum :: Identifier │ │ f :: Identifier │ │ fs :: Identifier │ │ [kw] │ │ init :: Identifier │ │ 0 :: Value │ │ [for] │ │ [=] │ │ [tuple] │ │ name :: Identifier │ │ attrib :: Identifier │ │ [call] │ │ pairs :: Identifier │ │ va :: Identifier │ │ [block] │ │ [if] │ │ [call] │ │ isa :: Identifier │ │ attrib :: Identifier │ │ FaceView :: Identifier │ │ [block] │ │ [try] │ │ [block] │ │ [call] │ │ verify :: Identifier │ │ fs :: Identifier │ │ attrib :: Identifier │ │ e :: Identifier │ │ [block] │ │ [call] │ │ rethrow :: Identifier │ │ [call] │ │ ErrorException :: Identifier │ │ [string] │ │ "Failed to verify " :: Value │ │ name :: Identifier │ │ " attribute:\n" :: Value │ │ [.] │ │ e :: Identifier │ │ [inert] │ │ msg :: Identifier │ │ [block] │ │ [&&] │ │ [call] │ │ < :: Identifier │ │ [call] │ │ length :: Identifier │ │ attrib :: Identifier │ │ N :: Identifier │ │ [call] │ │ error :: Identifier │ │ [string] │ │ "Failed to verify " :: Value │ │ name :: Identifier │ │ " attribute:\nFaces address " :: Value │ │ N :: Identifier │ │ " vertex attributes but only " :: Value │ │ [call] │ │ length :: Identifier │ │ attrib :: Identifier │ │ " are present." :: Value │ │ [return] │ │ [call] │ │ [curly] │ │ new :: Identifier │ │ Dim :: Identifier │ │ T :: Identifier │ │ FT :: Identifier │ │ names :: Identifier │ │ VAT :: Identifier │ │ FVT :: Identifier │ │ va :: Identifier │ │ fs :: Identifier │ │ views :: Identifier │ │ │ st1 = │ SyntaxTree with attributes mod,kind,var_id,toplevel_pure,scope_type,macro_source,name_val,syntax_flags,meta,scope_layer,value,jl_source,is_toplevel_thunk,source │ [block] │ │ [=] │ │ val :: Identifier │ scope_layer=3 │ [struct] │ │ false :: Value │ macro_source=256 │ [<:] │ scope_layer=1 │ [curly] │ │ Mesh :: Identifier │ scope_layer=1 │ Dim :: Identifier │ scope_layer=1 │ [<:] │ scope_layer=1 │ T :: Identifier │ scope_layer=1 │ Real :: Identifier │ scope_layer=1 │ [<:] │ scope_layer=1 │ FT :: Identifier │ scope_layer=1 │ AbstractFace :: Identifier │ scope_layer=1 │ Names :: Identifier │ scope_layer=1 │ [<:] │ scope_layer=1 │ VAT :: Identifier │ scope_layer=1 │ [curly] │ │ Tuple :: Identifier │ scope_layer=1 │ [<:] │ scope_layer=1 │ [curly] │ │ AbstractVector :: Identifier │ scope_layer=1 │ [curly] │ │ Point :: Identifier │ scope_layer=1 │ Dim :: Identifier │ scope_layer=1 │ T :: Identifier │ scope_layer=1 │ [curly] │ │ Vararg :: Identifier │ scope_layer=1 │ VertexAttributeType :: Identifier │ scope_layer=1 │ [<:] │ scope_layer=1 │ FVT :: Identifier │ scope_layer=1 │ [curly] │ │ AbstractVector :: Identifier │ scope_layer=1 │ FT :: Identifier │ scope_layer=1 │ [curly] │ │ AbstractMesh :: Identifier │ scope_layer=1 │ Dim :: Identifier │ scope_layer=1 │ T :: Identifier │ scope_layer=1 │ [block] │ │ [::] │ │ vertex_attributes :: Identifier │ scope_layer=1 │ [curly] │ │ NamedTuple :: Identifier │ scope_layer=1 │ Names :: Identifier │ scope_layer=1 │ VAT :: Identifier │ scope_layer=1 │ [::] │ │ faces :: Identifier │ scope_layer=1 │ FVT :: Identifier │ scope_layer=1 │ [::] │ │ views :: Identifier │ scope_layer=1 │ [curly] │ │ Vector :: Identifier │ scope_layer=1 │ [curly] │ │ UnitRange :: Identifier │ scope_layer=1 │ UInt32 :: Identifier │ scope_layer=1 │ [function] │ │ [where] │ │ [call] │ │ Mesh :: Identifier │ scope_layer=1 │ [::] │ │ vertex_attributes :: Identifier │ scope_layer=1 │ [curly] │ │ NamedTuple :: Identifier │ scope_layer=1 │ Names :: Identifier │ scope_layer=1 │ VAT :: Identifier │ scope_layer=1 │ [::] │ │ fs :: Identifier │ scope_layer=1 │ FVT :: Identifier │ scope_layer=1 │ [kw] │ │ [::] │ │ views :: Identifier │ scope_layer=1 │ [curly] │ │ Vector :: Identifier │ scope_layer=1 │ [<:] │ scope_layer=1 │ [curly] │ │ UnitRange :: Identifier │ scope_layer=1 │ [<:] │ scope_layer=1 │ Integer :: Identifier │ scope_layer=1 │ [ref] │ │ [curly] │ │ UnitRange :: Identifier │ scope_layer=1 │ UInt32 :: Identifier │ scope_layer=1 │ [<:] │ scope_layer=1 │ FT :: Identifier │ scope_layer=1 │ AbstractFace :: Identifier │ scope_layer=1 │ [<:] │ scope_layer=1 │ FVT :: Identifier │ scope_layer=1 │ [curly] │ │ AbstractVector :: Identifier │ scope_layer=1 │ FT :: Identifier │ scope_layer=1 │ Names :: Identifier │ scope_layer=1 │ Dim :: Identifier │ scope_layer=1 │ T :: Identifier │ scope_layer=1 │ [<:] │ scope_layer=1 │ VAT :: Identifier │ scope_layer=1 │ [curly] │ │ Tuple :: Identifier │ scope_layer=1 │ [<:] │ scope_layer=1 │ [curly] │ │ AbstractVector :: Identifier │ scope_layer=1 │ [curly] │ │ Point :: Identifier │ scope_layer=1 │ Dim :: Identifier │ scope_layer=1 │ T :: Identifier │ scope_layer=1 │ [curly] │ │ Vararg :: Identifier │ scope_layer=1 │ VertexAttributeType :: Identifier │ scope_layer=1 │ [block] │ │ [=] │ │ va :: Identifier │ scope_layer=1 │ vertex_attributes :: Identifier │ scope_layer=1 │ [=] │ │ names :: Identifier │ scope_layer=1 │ Names :: Identifier │ scope_layer=1 │ [if] │ │ [call] │ │ ! :: Identifier │ scope_layer=1 │ [call] │ │ haskey :: Identifier │ scope_layer=1 │ va :: Identifier │ scope_layer=1 │ [inert] │ │ position :: Identifier │ │ [block] │ │ [call] │ │ error :: Identifier │ scope_layer=1 │ "Vertex attributes must have a :position attribute." :: Value │ macro_source=256 │ [if] │ │ [call] │ │ haskey :: Identifier │ scope_layer=1 │ va :: Identifier │ scope_layer=1 │ [inert] │ │ normals :: Identifier │ │ [block] │ │ [block] │ │ [let] │ │ [block] │ macro_source=256 │ [block] │ │ [=] │ │ #7#level :: Identifier │ scope_layer=1 │ Warn :: Identifier │ mod,scope_layer=1 │ [=] │ │ #8#std_level :: Identifier │ scope_layer=1 │ #7#level :: Identifier │ scope_layer=1 │ [if] │ │ [call] │ │ >= :: Identifier │ mod,scope_layer=1 │ [.] │ │ #8#std_level :: Identifier │ scope_layer=1 │ [inert] │ │ level :: Identifier │ │ [ref] │ macro_source=256 │ Base.Threads.Atomic{Int32}(-1000) :: Value │ macro_source=256 │ [block] │ │ [=] │ │ #9#group :: Identifier │ scope_layer=1 │ [inert] │ │ basic_types :: Identifier │ │ [=] │ │ #10#_module :: Identifier │ scope_layer=1 │ GeometryBasics :: Value │ macro_source=256 │ [=] │ │ #11#logger :: Identifier │ scope_layer=1 │ [call] │ │ Base.CoreLogging.current_logger_for_env :: Value │ macro_source=256 │ #8#std_level :: Identifier │ scope_layer=1 │ #9#group :: Identifier │ scope_layer=1 │ #10#_module :: Identifier │ scope_layer=1 │ [if] │ │ [call] │ │ ! :: Identifier │ mod,scope_layer=1 │ [call] │ │ === :: Identifier │ mod,scope_layer=1 │ #11#logger :: Identifier │ scope_layer=1 │ nothing :: Identifier │ mod,scope_layer=1 │ [block] │ │ [=] │ │ #12#id :: Identifier │ scope_layer=1 │ [inert] │ │ GeometryBasics_1e57c75a :: Identifier │ │ [if] │ │ [call] │ │ invokelatest :: Identifier │ mod,scope_layer=1 │ Base.CoreLogging.shouldlog :: Value │ macro_source=256 │ #11#logger :: Identifier │ scope_layer=1 │ #7#level :: Identifier │ scope_layer=1 │ #10#_module :: Identifier │ scope_layer=1 │ #9#group :: Identifier │ scope_layer=1 │ #12#id :: Identifier │ scope_layer=1 │ [block] │ │ [=] │ │ #13#file :: Identifier │ scope_layer=1 │ "/home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl" :: Value │ macro_source=256 │ [if] │ │ [call] │ │ isa :: Identifier │ mod,scope_layer=1 │ #13#file :: Identifier │ scope_layer=1 │ String :: Identifier │ mod,scope_layer=1 │ [block] │ │ [=] │ │ #13#file :: Identifier │ scope_layer=1 │ [call] │ │ [.] │ │ Base :: Identifier │ mod,scope_layer=1 │ [inert] │ │ fixup_stdlib_path :: Identifier │ │ #13#file :: Identifier │ scope_layer=1 │ [=] │ │ #14#line :: Identifier │ scope_layer=1 │ 533 :: Value │ macro_source=256 │ [local] │ │ #15#msg :: Identifier │ scope_layer=1 │ #16#kwargs :: Identifier │ scope_layer=1 │ [if] │ │ [block] │ │ [=] │ │ #15#msg :: Identifier │ scope_layer=1 │ "`normals` as a vertex attribute name has been deprecated in favor of `normal` to bring it in line with mesh.position and mesh.uv" :: Value │ macro_source=256 │ [=] │ │ #16#kwargs :: Identifier │ scope_layer=1 │ [tuple] │ macro_source=256 │ [parameters] │ macro_source=256 │ true :: Value │ macro_source=256 │ [block] │ │ [if] │ │ [isdefined] │ │ #15#msg :: Identifier │ scope_layer=1 │ nothing :: Value │ macro_source=256 │ [call] │ │ throw :: Identifier │ mod,scope_layer=1 │ [call] │ │ AssertionError :: Identifier │ mod,scope_layer=1 │ "Assertion to tell the compiler about the definedness of this variable" :: Value │ macro_source=256 │ [if] │ │ [isdefined] │ │ #16#kwargs :: Identifier │ scope_layer=1 │ nothing :: Value │ macro_source=256 │ [call] │ │ throw :: Identifier │ mod,scope_layer=1 │ [call] │ │ AssertionError :: Identifier │ mod,scope_layer=1 │ "Assertion to tell the compiler about the definedness of this variable" :: Value │ macro_source=256 │ [call] │ │ Base.CoreLogging.handle_message_nothrow :: Value │ macro_source=256 │ [parameters] │ │ [...] │ │ #16#kwargs :: Identifier │ scope_layer=1 │ #11#logger :: Identifier │ scope_layer=1 │ #7#level :: Identifier │ scope_layer=1 │ #15#msg :: Identifier │ scope_layer=1 │ #10#_module :: Identifier │ scope_layer=1 │ #9#group :: Identifier │ scope_layer=1 │ #12#id :: Identifier │ scope_layer=1 │ #13#file :: Identifier │ scope_layer=1 │ #14#line :: Identifier │ scope_layer=1 │ nothing :: Identifier │ mod,scope_layer=1 │ [=] │ │ names :: Identifier │ scope_layer=1 │ [call] │ │ ntuple :: Identifier │ scope_layer=1 │ [->] │ │ i :: Identifier │ scope_layer=1 │ [block] │ │ [call] │ │ ifelse :: Identifier │ scope_layer=1 │ [call] │ │ == :: Identifier │ scope_layer=1 │ [ref] │ │ names :: Identifier │ scope_layer=1 │ i :: Identifier │ scope_layer=1 │ [inert] │ │ normal :: Identifier │ │ [inert] │ │ normal :: Identifier │ │ [ref] │ │ names :: Identifier │ scope_layer=1 │ i :: Identifier │ scope_layer=1 │ [call] │ │ length :: Identifier │ scope_layer=1 │ names :: Identifier │ scope_layer=1 │ [=] │ │ va :: Identifier │ scope_layer=1 │ [call] │ │ [curly] │ │ NamedTuple :: Identifier │ scope_layer=1 │ names :: Identifier │ scope_layer=1 │ [call] │ │ values :: Identifier │ scope_layer=1 │ va :: Identifier │ scope_layer=1 │ [=] │ │ N :: Identifier │ scope_layer=1 │ [call] │ │ maximum :: Identifier │ scope_layer=1 │ [->] │ │ f :: Identifier │ scope_layer=1 │ [block] │ │ [call] │ │ value :: Identifier │ scope_layer=1 │ [call] │ │ maximum :: Identifier │ scope_layer=1 │ f :: Identifier │ scope_layer=1 │ fs :: Identifier │ scope_layer=1 │ [kw] │ │ init :: Identifier │ scope_layer=1 │ 0 :: Value │ macro_source=256 │ [for] │ │ [=] │ │ [tuple] │ │ name :: Identifier │ scope_layer=1 │ attrib :: Identifier │ scope_layer=1 │ [call] │ │ pairs :: Identifier │ scope_layer=1 │ va :: Identifier │ scope_layer=1 │ [block] │ │ [if] │ │ [call] │ │ isa :: Identifier │ scope_layer=1 │ attrib :: Identifier │ scope_layer=1 │ FaceView :: Identifier │ scope_layer=1 │ [block] │ │ [try] │ │ [block] │ │ [call] │ │ verify :: Identifier │ scope_layer=1 │ fs :: Identifier │ scope_layer=1 │ attrib :: Identifier │ scope_layer=1 │ e :: Identifier │ scope_layer=1 │ [block] │ │ [call] │ │ rethrow :: Identifier │ scope_layer=1 │ [call] │ │ ErrorException :: Identifier │ scope_layer=1 │ [string] │ │ "Failed to verify " :: Value │ macro_source=256 │ name :: Identifier │ scope_layer=1 │ " attribute:\n" :: Value │ macro_source=256 │ [.] │ │ e :: Identifier │ scope_layer=1 │ [inert] │ │ msg :: Identifier │ │ [block] │ │ [&&] │ │ [call] │ │ < :: Identifier │ scope_layer=1 │ [call] │ │ length :: Identifier │ scope_layer=1 │ attrib :: Identifier │ scope_layer=1 │ N :: Identifier │ scope_layer=1 │ [call] │ │ error :: Identifier │ scope_layer=1 │ [string] │ │ "Failed to verify " :: Value │ macro_source=256 │ name :: Identifier │ scope_layer=1 │ " attribute:\nFaces address " :: Value │ macro_source=256 │ N :: Identifier │ scope_layer=1 │ " vertex attributes but only " :: Value │ macro_source=256 │ [call] │ │ length :: Identifier │ scope_layer=1 │ attrib :: Identifier │ scope_layer=1 │ " are present." :: Value │ macro_source=256 │ [return] │ │ [call] │ │ [curly] │ │ new :: Identifier │ scope_layer=1 │ Dim :: Identifier │ scope_layer=1 │ T :: Identifier │ scope_layer=1 │ FT :: Identifier │ scope_layer=1 │ names :: Identifier │ scope_layer=1 │ VAT :: Identifier │ scope_layer=1 │ FVT :: Identifier │ scope_layer=1 │ va :: Identifier │ scope_layer=1 │ fs :: Identifier │ scope_layer=1 │ views :: Identifier │ scope_layer=1 │ [call] │ │ Base.Docs.doc! :: Value │ macro_source=256 │ GeometryBasics :: Value │ macro_source=256 │ [call] │ │ Base.Docs.Binding :: Value │ macro_source=256 │ GeometryBasics :: Value │ │ [inert] │ jl_source=L65 │ Mesh :: Identifier │ │ [call] │ │ Base.Docs.docstr :: Value │ macro_source=256 │ [call] │ macro_source=256 │ Core.svec :: Value │ macro_source=256 │ " Mesh{PositionDim, PositionType, FaceType, VertexAttributeNames, VertexAttributeTypes, FaceVectorType} <: AbstractMesh{PositionDim, PositionType} <: AbstractGeometry{PositionDim, PositionType}\n\nThe type of a concrete mesh. The associated struct contains 3 fields:\n\n```julia\nstruct Mesh{...}\n vertex_attributes::NamedTuple{VertexAttributeNames, VertexAttributeTypes}\n faces::FaceVectorType\n views::Vector{UnitRange{Int}}\nend\n```\n\nA vertex typically carries multiple distinct pieces of data, e.g. a position,\na normal, a texture coordinate, etc. We call those pieces of data vertex\nattributes. The `vertex_attributes` field contains the name and a collection\n`<: AbstractVector` or `<: FaceView` for each attribute. The n-th element of that\ncollection is the value of the corresponding attribute for the n-th vertex.\n\n```julia\n# vertex 1 2 3\nvertex_attributes[:position] = [pos1, pos2, pos3, ...]\nvertex_attributes[:normal] = [normal1, normal2, normal3, ...]\n...\n```\n\nA `NamedTuple` is used here to allow different meshes to carry different vertex\nattributes while also keeping things type stable. The constructor enforces a\nfew restrictions:\n- The first attribute must be named `position` and must have a `Point{PositionDim, PositionType}` eltype.\n- Each vertex attribute must refer to the same number of vertices. (All vertex attributes defined by\nAbstractVector must match in length. For FaceViews, the number of faces needs to match.)\n\nSee also: [`vertex_attributes`](@ref), [`coordinates`](@ref), [`normals`](@ref),\n[`texturecoordinates`](@ref), [`decompose`](@ref), [`FaceView`](@ref),\n[`expand_faceviews`](@ref)\n\nThe `faces` field is a collection `<: AbstractVector{FaceType}` containing faces\nthat describe how vertices are connected. Typically these are `(GL)TriangleFace`s\nor `QuadFace`s, but they can be any collection of vertex indices `<: AbstractFace`.\n\nSee also: [`faces`](@ref), [`decompose`](@ref)\n\nThe `views` field can be used to separate the mesh into mutliple submeshes. Each\nsubmesh is described by a \"view\" into the `faces` vector, i.e. submesh n uses\n`mesh.faces[mesh.views[n]]`. A `Mesh` can be constructed without `views`, which\nresults in an empty `views` vector.\n\nSee also: [`merge`](@ref), [`split_mesh`](@ref)\n" :: Value │ macro_source=256 │ [call] │ │ Dict{Symbol, Any} :: Value │ macro_source=256 │ :path => "/home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl" :: Value │ macro_source=256 │ :linenumber => 453 :: Value │ macro_source=256 │ :module => GeometryBasics :: Value │ macro_source=256 │ [call] │ │ Pair :: Value │ macro_source=256 │ [inert] │ │ fields :: Identifier │ │ [call] │ macro_source=256 │ Dict{Symbol, Any} :: Value │ macro_source=256 │ [curly] │ │ Union :: Identifier │ scope_layer=1 │ val :: Identifier │ scope_layer=3 │ │ file = "/home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl" │ line = 453 └ mod = GeometryBasics ERROR: LoadError: internal lowering bug: #= /home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl:515 =# - `jl_assert(!(haskey(ssa_rewrites, lhs_id)), _)`: multiple assignments to ssavalue Expression:  (= #₂₆ (call core.TypeVar :#T1 #₂₈₉)) Containing expressions:  (= #₂₆ (call core.TypeVar :#T1 #₂₈₉))  Detailed provenance:  (= #₂₆ (call core.TypeVar :#T1 #₂₈₉)) @#= /source/usr/share/julia/JuliaLowering/src/linear_ir.jl:366 =#  └─ (= #₂₆ (call core.TypeVar :#T1 (call core.apply_type #₅₆/AbstractVector (call core.apply_type #₅₇/Point #₆₉/Dim #₇₀/T)))) @#= /source/usr/share/julia/JuliaLowering/src/closure_conversion.jl:197 =#  └─ (= #₂₆ (call core.TypeVar :#T1 (call core.apply_type #₅₆/AbstractVector (call core.apply_type #₅₇/Point #₆₉/Dim #₇₀/T)))) @#= /source/usr/share/julia/JuliaLowering/src/desugaring.jl:231 =#  └─ (= #₂₆ (call core.TypeVar :#T1 (call core.apply_type AbstractVector (call core.apply_type Point Dim T)))) @#= /source/usr/share/julia/JuliaLowering/src/desugaring.jl:231 =#  └─ (= #₂₆ (call core.TypeVar :#T1 (curly AbstractVector (curly Point Dim T))))  └─ (call core.TypeVar :#T1 (curly AbstractVector (curly Point Dim T))) @#= /source/usr/share/julia/JuliaLowering/src/desugaring.jl:3025 =#  └─ (<: (curly AbstractVector (curly Point Dim T)))  └─ (<: (curly AbstractVector (curly Point Dim T)))  └─ (<: (curly AbstractVector (curly Point Dim T)))  └─ (<: (curly AbstractVector (curly Point Dim T)))  ├─ @ /home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl:515  └─ (macrocall @doc :(#= /home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl:453 =#) " Mesh{PositionDim, PositionType, FaceType, VertexAttributeNames, VertexAttributeTypes, FaceVectorType} <: AbstractMesh{PositionDim, PositionType} <: AbstractGeometry{PositionDim, PositionType}\n\nThe type of a concrete mesh. The associated struct contains 3 fields:\n\n```julia\nstruct Mesh{...}\n vertex_attributes::NamedTuple{VertexAttributeNames, VertexAttributeTypes}\n faces::FaceVectorType\n views::Vector{UnitRange{Int}}\nend\n```\n\nA vertex typically carries multiple distinct pieces of data, e.g. a position,\na normal, a texture coordinate, etc. We call those pieces of data vertex\nattributes. The `vertex_attributes` field contains the name and a collection\n`<: AbstractVector` or `<: FaceView` for each attribute. The n-th element of that\ncollection is the value of the corresponding attribute for the n-th vertex.\n\n```julia\n# vertex 1 2 3\nvertex_attributes[:position] = [pos1, pos2, pos3, ...]\nvertex_attributes[:normal] = [normal1, normal2, normal3, ...]\n...\n```\n\nA `NamedTuple` is used here to allow different meshes to carry different vertex\nattributes while also keeping things type stable. The constructor enforces a\nfew restrictions:\n- The first attribute must be named `position` and must have a `Point{PositionDim, PositionType}` eltype.\n- Each vertex attribute must refer to the same number of vertices. (All vertex attributes defined by\nAbstractVector must match in length. For FaceViews, the number of faces needs to match.)\n\nSee also: [`vertex_attributes`](@ref), [`coordinates`](@ref), [`normals`](@ref),\n[`texturecoordinates`](@ref), [`decompose`](@ref), [`FaceView`](@ref),\n[`expand_faceviews`](@ref)\n\nThe `faces` field is a collection `<: AbstractVector{FaceType}` containing faces\nthat describe how vertices are connected. Typically these are `(GL)TriangleFace`s\nor `QuadFace`s, but they can be any collection of vertex indices `<: AbstractFace`.\n\nSee also: [`faces`](@ref), [`decompose`](@ref)\n\nThe `views` field can be used to separate the mesh into mutliple submeshes. Each\nsubmesh is described by a \"view\" into the `faces` vector, i.e. submesh n uses\n`mesh.faces[mesh.views[n]]`. A `Mesh` can be constructed without `views`, which\nresults in an empty `views` vector.\n\nSee also: [`merge`](@ref), [`split_mesh`](@ref)\n" (struct false (<: (curly Mesh Dim (<: T Real) (<: FT AbstractFace) Names (<: VAT (curly Tuple (<: (curly AbstractVector (curly Point Dim T))) (curly Vararg VertexAttributeType))) (<: FVT (curly AbstractVector FT))) (curly AbstractMesh Dim T)) (block (:: vertex_attributes (curly NamedTuple Names VAT)) (:: faces FVT) (:: views (curly Vector (curly UnitRange UInt32))) (function (where (call Mesh (:: vertex_attributes (curly NamedTuple Names VAT)) (:: fs FVT) (kw (:: views (curly Vector (<: (curly UnitRange (<: Integer))))) (ref (curly UnitRange UInt32)))) (<: FT AbstractFace) (<: FVT (curly AbstractVector FT)) Names Dim T (<: VAT (curly Tuple (<: (curly AbstractVector (curly Point Dim T))) (curly Vararg VertexAttributeType)))) (block (= va vertex_attributes) (= names Names) (if (call ! (call haskey va (inert position))) (block (call error "Vertex attributes must have a :position attribute."))) (if (call haskey va (inert normals)) (block (macrocall @warn :(#= /home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl:533 =#) "`normals` as a vertex attribute name has been deprecated in favor of `normal` to bring it in line with mesh.position and mesh.uv") (= names (call ntuple (-> i (block (call ifelse (call == (ref names i) (inert normal)) (inert normal) (ref names i)))) (call length names))) (= va (call (curly NamedTuple names) (call values va))))) (= N (call maximum (-> f (block (call value (call maximum f)))) fs (kw init 0))) (for (= (tuple name attrib) (call pairs va)) (block (if (call isa attrib FaceView) (block (try (block (call verify fs attrib)) e (block (call rethrow (call ErrorException (string "Failed to verify " name " attribute:\n" (. e (inert msg)))))))) (block (&& (call < (call length attrib) N) (call error (string "Failed to verify " name " attribute:\nFaces address " N " vertex attributes but only " (call length attrib) " are present."))))))) (return (call (curly new Dim T FT names VAT FVT) va fs views)))))))  └─ @ /home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl:453  Stacktrace:  [1] iterate(A::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, Vector{Int64}})  @ Base /source/usr/share/julia/JuliaLowering/src/ast.jl:23 [inlined]  [2] renumber_body(ctx::Base.JuliaLowering.LinearIRContext{Dict{Symbol, Dict{Int64, Any}}}, input_code::Base.JuliaSyntax.SyntaxList{Dict{Symbol, Dict{Int64, Any}}, Vector{Int64}}, slot_rewrites::Dict{Int64, Int64})  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/linear_ir.jl:1106  [3] compile_lambda(outer_ctx::Base.JuliaLowering.LinearIRContext{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}})  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/linear_ir.jl:1223  [4] linearize_ir(ctx::Base.JuliaLowering.ClosureConversionCtx{Dict{Symbol, Dict{Int64, Any}}}, ex::Base.JuliaSyntax.SyntaxTree{Dict{Symbol, Dict{Int64, Any}}})  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/linear_ir.jl:1253  [5] core_lowering_hook(code::Any, mod::Module, file::String, line::UInt64, world::UInt64, _warn::Bool)  @ Base.JuliaLowering /source/usr/share/julia/JuliaLowering/src/hooks.jl:33  [6] include(mapexpr::Function, mod::Module, _path::String)  @ Base ./Base.jl:327  [7] top-level scope  @ ~/.julia/packages/GeometryBasics/yB1f1/src/GeometryBasics.jl:12  [8] include(mod::Module, _path::String)  @ Base ./Base.jl:326  [9] 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  [10] top-level scope  @ stdin:5  [11] eval(m::Module, e::Any)  @ Core ./boot.jl:517  [12] include_string(mapexpr::typeof(identity), mod::Module, code::String, filename::String)  @ Base ./loading.jl:3113  [13] push!(a::Vector{SubString{String}}, item::String)  @ Base ./loading.jl:3123 [inlined]  [14] exec_options(opts::Base.JLOptions)  @ Base ./client.jl:353  [15] _start()  @ Base ./client.jl:596 in expression starting at /home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/basic_types.jl:453 in expression starting at /home/pkgeval/.julia/packages/GeometryBasics/yB1f1/src/GeometryBasics.jl:1 in expression starting at stdin:5 1 dependency had output during precompilation: ┌ GeometryBasics │ [Output was shown above] └ ERROR: LoadError: The following 1 package failed to precompile: GeometryBasics Failed to precompile GeometryBasics [5c1252a2-5f33-56bf-86c9-59e7332b4326] to "/home/pkgeval/.julia/compiled/v1.14/GeometryBasics/jl_H04SMV" (ProcessExited(1)). in expression starting at /home/pkgeval/.julia/packages/GeometryBasics/yB1f1/test/runtests.jl:2 Testing failed after 396.26s ERROR: LoadError: Package GeometryBasics errored during testing Stacktrace: [1] pkgerror(msg::String) @ Pkg.Types /opt/julia/share/julia/stdlib/v1.14/Pkg/src/Types.jl:68 [2] test(ctx::Pkg.Types.Context, pkgs::Vector{PackageSpec}; coverage::Bool, julia_args::Cmd, test_args::Cmd, test_fn::Nothing, force_latest_compatible_version::Bool, allow_earlier_backwards_compatible_versions::Bool, allow_reresolve::Bool) @ Pkg.Operations /opt/julia/share/julia/stdlib/v1.14/Pkg/src/Operations.jl:3247 [3] Cmd(cmd::Cmd) @ Base /opt/julia/share/julia/stdlib/v1.14/Pkg/src/Operations.jl:3110 [inlined] [4] test(ctx::Pkg.Types.Context, pkgs::Vector{PackageSpec}; coverage::Bool, test_fn::Nothing, julia_args::Cmd, test_args::Cmd, force_latest_compatible_version::Bool, allow_earlier_backwards_compatible_versions::Bool, allow_reresolve::Bool, kwargs::@Kwargs{io::IOContext{IO}}) @ Pkg.API /opt/julia/share/julia/stdlib/v1.14/Pkg/src/API.jl:587 [5] test(pkgs::Vector{PackageSpec}; io::IOContext{IO}, kwargs::@Kwargs{julia_args::Cmd}) @ Pkg.API /opt/julia/share/julia/stdlib/v1.14/Pkg/src/API.jl:172 [6] test(pkgs::Vector{String}; kwargs::@Kwargs{julia_args::Cmd}) @ Pkg.API /opt/julia/share/julia/stdlib/v1.14/Pkg/src/API.jl:160 [7] test @ /opt/julia/share/julia/stdlib/v1.14/Pkg/src/API.jl:160 [inlined] [8] test(pkg::String; kwargs::@Kwargs{julia_args::Cmd}) @ Pkg.API /opt/julia/share/julia/stdlib/v1.14/Pkg/src/API.jl:159 [inlined] [9] top-level scope @ /PkgEval.jl/scripts/evaluate.jl:223 [10] include(mod::Module, _path::String) @ Base ./Base.jl:326 [11] exec_options(opts::Base.JLOptions) @ Base ./client.jl:355 [12] _start() @ Base ./client.jl:596 in expression starting at /PkgEval.jl/scripts/evaluate.jl:214 PkgEval failed after 2340.38s: package fails to precompile