Revert FieldArray behavior to pre-0.6 (#207)

* restricting StaticArrays schema to SArray instead of <:StaticArray

* add test

* use `invoke` for FieldArray types

* add test

* specializing StructArrays.components for FieldArray

* adding more tests

* Update src/staticarrays_support.jl

Co-authored-by: Pietro Vertechi <pietro.vertechi@protonmail.com>

* add createinstance

* edit FlippedVec2D tuple constructor

Co-authored-by: Jesse Chan <jesse.chan@rice.edu>
Co-authored-by: Pietro Vertechi <pietro.vertechi@protonmail.com>

Author: jlchan

src/staticarrays_support.jl

@@ -1,4 +1,4 @@
-import StaticArrays: StaticArray, tuple_prod
+import StaticArrays: StaticArray, FieldArray, tuple_prod
 
 """
     StructArrays.staticschema(::Type{<:StaticArray{S, T}}) where {S, T}
@@ -8,6 +8,9 @@ The `staticschema` of a `StaticArray` element type is the `staticschema` of the
 julia> StructArrays.staticschema(SVector{2, Float64})
 Tuple{Float64, Float64}
 ```
+The one exception to this rule is `<:StaticArrays.FieldArray`, since `FieldArray` is based on a 
+struct. In this case, `staticschema(<:FieldArray)` returns the `staticschema` for the struct 
+which subtypes `FieldArray`. 
 """
 @generated function StructArrays.staticschema(::Type{<:StaticArray{S, T}}) where {S, T}
     return quote
@@ -17,3 +20,10 @@ Tuple{Float64, Float64}
 end
 StructArrays.createinstance(::Type{T}, args...) where {T<:StaticArray} = T(args)
 StructArrays.component(s::StaticArray, i) = getindex(s, i)
+
+# invoke general fallbacks for a `FieldArray` type.
+@inline function StructArrays.staticschema(T::Type{<:FieldArray})
+    invoke(StructArrays.staticschema, Tuple{Type{<:Any}}, T)
+end
+StructArrays.component(s::FieldArray, i) = invoke(StructArrays.component, Tuple{Any, Any}, s, i)
+StructArrays.createinstance(T::Type{<:FieldArray}, args...) = invoke(createinstance, Tuple{Type{<:Any}, Vararg}, T, args...)

test/runtests.jl

@@ -852,6 +852,26 @@ end
         @test x .+ y == StructArray([StaticArrayType{Tuple{1,2}}(3*ones(1,2) .+ 2*i) for i = 0:1])
     end
 
+    # test FieldVector constructor (see https://github.com/JuliaArrays/StructArrays.jl/issues/205)
+    struct FlippedVec2D <: FieldVector{2,Float64}
+        x::Float64
+        y::Float64
+    end
+    # tuple constructors should respect the flipped ordering
+    FlippedVec2D(t::Tuple) = FlippedVec2D(t[2], t[1])
+
+    # define a custom getindex to test StructArrays.component(::FieldArray) behavior
+    Base.getindex(a::FlippedVec2D, index::Int) = index==1 ? a.y : a.x
+    Base.Tuple(a::FlippedVec2D) = (a.y, a.x)
+    a = StructArray([FlippedVec2D(1.0,2.0)])
+    @test a.x == [1.0]
+    @test a.y == [2.0]
+    @test a.x[1] == a[1].x
+
+    # test custom indices and components
+    @test typeof(StructArrays.components(a)) == NamedTuple{(:x, :y), NTuple{2, Vector{Float64}}}
+    @test StructArrays.components(a) == (; x = [1.0], y = [2.0])    
+
     # test type stability of creating views with "many" homogeneous components
     for n in 1:10
         u = StructArray(randn(SVector{n, Float64}) for _ in 1:10, _ in 1:5)