Use more specific check on widening (#81)

Author: Pietro Vertechi

src/collect.jl

@@ -109,27 +109,22 @@ function grow_to_structarray!(dest::AbstractArray, itr, elem = iterate(itr))
     return dest
 end
 
-widenstructarray(dest::AbstractArray, i, el::S) where {S} = widenstructarray(dest, i, S)
-
-function widenstructarray(dest::StructArray{T}, i, ::Type{S}) where {T, S}
-    sch = staticschema(S)
-    names = fieldnames(sch)
-    types = ntuple(i -> fieldtype(sch, i), fieldcount(sch))
-    cols = fieldarrays(dest)
-    if names == propertynames(cols)
-        nt = map((a, b) -> widenstructarray(a, i, b), cols, strip_params(sch)(types))
-        ST = _promote_typejoin(S, T)
-        return StructArray{ST}(nt)
-    else
-        return widenarray(dest, i, S)
-    end
+widenstructarray(dest::AbstractArray{S}, i, el::T) where {S, T} = widenstructarray(dest, i, _promote_typejoin(S, T))
+
+function widenstructarray(dest::StructArray, i, ::Type{T}) where {T}
+    sch = hasfields(T) ? staticschema(T) : nothing
+    sch !== nothing && fieldnames(sch) == propertynames(dest) || return widenarray(dest, i, T)
+    types = ntuple(x -> fieldtype(sch, x), fieldcount(sch))
+    cols = Tuple(fieldarrays(dest))
+    newcols = map((a, b) -> widenstructarray(a, i, b), cols, types)
+    return StructArray{T}(newcols)
 end
 
-widenstructarray(dest::AbstractArray, i, ::Type{S}) where {S} = widenarray(dest, i, S)
+widenstructarray(dest::AbstractArray, i, ::Type{T}) where {T} = widenarray(dest, i, T)
 
-widenarray(dest::AbstractArray{S}, i, ::Type{S}) where {S} = dest
-function widenarray(dest::AbstractArray{S}, i, ::Type{T}) where {S, T}
-    new = similar(dest, Base.promote_typejoin(S, T), length(dest))
+widenarray(dest::AbstractArray{T}, i, ::Type{T}) where {T} = dest
+function widenarray(dest::AbstractArray, i, ::Type{T}) where T
+    new = similar(dest, T, length(dest))
     copyto!(new, 1, dest, 1, i-1)
     new
 end

src/structarray.jl

@@ -51,10 +51,21 @@ StructVector(args...; kwargs...) = StructArray(args...; kwargs...)
 
 Base.IndexStyle(::Type{S}) where {S<:StructArray} = _indexstyle(_best_index(S))
 
-_undef_array(::Type{T}, sz; unwrap = t -> false) where {T} = unwrap(T) ? StructArray{T}(undef, sz; unwrap = unwrap) : Array{T}(undef, sz)
+function _undef_array(::Type{T}, sz; unwrap = t -> false) where {T}
+    if unwrap(T)
+        return StructArray{T}(undef, sz; unwrap = unwrap)
+    else
+        return Array{T}(undef, sz)
+    end
+end
 
-_similar(v::AbstractArray, ::Type{Z}; unwrap = t -> false) where {Z} =
-    unwrap(Z) ? buildfromschema(typ -> _similar(v, typ; unwrap = unwrap), Z) : similar(v, Z)
+function _similar(v::AbstractArray, ::Type{Z}; unwrap = t -> false) where {Z}
+    if unwrap(Z)
+        return buildfromschema(typ -> _similar(v, typ; unwrap = unwrap), Z)
+    else
+        return similar(v, Z)
+    end
+end
 
 function StructArray{T}(::Base.UndefInitializer, sz::Dims; unwrap = t -> false) where {T}
     buildfromschema(typ -> _undef_array(typ, sz; unwrap = unwrap), T)
@@ -65,7 +76,10 @@ function similar_structarray(v::AbstractArray, ::Type{Z}; unwrap = t -> false) w
     buildfromschema(typ -> _similar(v, typ; unwrap = unwrap), Z)
 end
 
-StructArray(v; unwrap = t -> false) = collect_structarray(v; initializer = StructArrayInitializer(unwrap))
+function StructArray(v; unwrap = t -> false)::StructArray
+    collect_structarray(v; initializer = StructArrayInitializer(unwrap))
+end
+
 function StructArray(v::AbstractArray{T}; unwrap = t -> false) where {T}
     s = similar_structarray(v, T; unwrap = unwrap)
     for i in eachindex(v)

src/utils.jl

@@ -130,3 +130,9 @@ astuple(::Type{T}) where {T<:Tuple} = T
 
 strip_params(::Type{<:Tuple}) = Tuple
 strip_params(::Type{<:NamedTuple{names}}) where {names} = NamedTuple{names}
+
+hasfields(::Type{<:Tup}) = false
+hasfields(::Type{<:NTuple{N, Any}}) where {N} = true
+hasfields(::Type{<:NamedTuple{names}}) where {names} = true
+hasfields(::Type{T}) where {T} = !isabstracttype(T)
+hasfields(::Union) = false

test/runtests.jl

@@ -530,6 +530,19 @@ end
     @test sa.a == fill(1, -2:7)
 end
 
+@testset "hasfields" begin
+    @test StructArrays.hasfields(ComplexF64)
+    @test !StructArrays.hasfields(Any)
+    @test StructArrays.hasfields(Tuple{Union{Int, Missing}})
+    @test StructArrays.hasfields(typeof((a=1,)))
+    @test !StructArrays.hasfields(NamedTuple)
+    @test !StructArrays.hasfields(Tuple{Int, Vararg{Int, N}} where {N})
+    @test StructArrays.hasfields(Missing)
+    @test !StructArrays.hasfields(Union{Tuple{Int}, Missing})
+    @test StructArrays.hasfields(Nothing)
+    @test !StructArrays.hasfields(Union{Tuple{Int}, Nothing})
+end
+
 @testset "reshape" begin
     s = StructArray(a=[1,2,3,4], b=["a","b","c","d"])
     rs = reshape(s, (2, 2))