Make Vector{Union{}} arraylike, not dictlike

[krynju]

Union{} is a subtype of every type, so Vector{Union{}} <: AbstractVector{<:Pair} holds and

dictlike(::Type{<:AbstractVector{<:Pair}}) = true

matches it, while arraylike(::Type{<:AbstractArray}) = true matches it too. The two traits disagree for a type that can only ever be an empty array, and make checks dictlike first, so such vectors are built through makedict (and make! on one goes through the dict path as well).

This adds a more specific method:

dictlike(::Type{<:AbstractVector{Union{}}}) = false

Before / after:

julia> StructUtils.dictlike(Vector{Union{}}), StructUtils.arraylike(Vector{Union{}})
(true, true)    # before
(false, true)   # after

julia> StructUtils.dictlike(Vector{<:Pair}), StructUtils.dictlike(Vector{Pair{String,Int}})
(true, true)    # unchanged

Observable behaviour is nearly identical since the vector is always empty: make(Vector{Union{}}, []) and make(Vector{Union{}}, Dict()) still return Union{}[], and a non-empty source still throws. The point is trait consistency for downstream consumers that branch on dictlike before arraylike the way make does. This surfaced while fixing JuliaIO/JSON.jl#499, where the same Union{} <: Pair subtyping made JSON.jl write Union{}[] as {} (fixed on the JSON.jl side in JuliaIO/JSON.jl#500; that fix does not depend on this one).

The other Pair-vector special cases here (applyeach, _keytype, _valtype) use the invariant AbstractVector{Pair{K,V}} and are not affected. Test.detect_ambiguities(StructUtils) is unchanged (1 default, 51 with ambiguous_bottom=true). Full test suite passes locally on Julia 1.12.7, including the trim-compile stage.

Second commit, from a self-review pass:

• make(Union{}, source) (reached e.g. via make(Vector{Union{}}, [1])) used to fall into the T <: Tuple branch and die inside fieldcount(Union{}) with "The empty type does not have a well-defined number of fields". It now throws a dedicated, type-free ArgumentError("cannot make a value of type Union{} because it has no instances") from a @noinline helper, same shape as _absentfield_error. The T === Union{} check constant-folds away for every other T.
• The dictlike docstring now mentions the AbstractVector{<:Pair} rule and the Union{} exception.
• Tests: swapped two Union{Vector{Union{}}, Dict} selection assertions that passed with or without the fix (union disambiguation only consults arraylike) for a make! check and the exact error messages.

One thing I left for you to decide: dictlike(::Type{<:AbstractVector{<:Pair}}) is covariant, but every consumer of a dictlike Pair vector (applyeach, _keytype/_valtype, addkeyval!) only handles the invariant AbstractVector{Pair{K,V}}, so e.g. make(Vector{Pair}, Dict("a" => 1)) fails on liftkey(Int, "a") and make(Vector{<:Pair}, ...) has no (undef, 0) constructor. Tightening the rule to AbstractVector{Pair{K,V}} where {K,V} would also make the Union{} special case unnecessary, but it changes what dictlike(Vector{<:Pair}) reports, so I kept the narrower fix here.

🤖 Generated with Claude Code