Preserve more FieldArrays with parametric eltype.

And return a `MArray` for mutable `FieldArray`

src/FieldArray.jl

@@ -125,14 +125,21 @@ Base.cconvert(::Type{<:Ptr}, a::FieldArray) = Base.RefValue(a)
 Base.unsafe_convert(::Type{Ptr{T}}, m::Base.RefValue{FA}) where {N,T,D,FA<:FieldArray{N,T,D}} =
     Ptr{T}(Base.unsafe_convert(Ptr{FA}, m))
 
-# We can automatically preserve FieldArrays in array operations which do not
-# change their eltype or Size. This should cover all non-parametric FieldArray,
-# but for those which are parametric on the eltype the user will still need to
-# overload similar_type themselves.
-similar_type(::Type{A}, ::Type{T}, S::Size) where {N, T, A<:FieldArray{N, T}} =
-    _fieldarray_similar_type(A, T, S, Size(A))
-
-# Extra layer of dispatch to match NewSize and OldSize
-_fieldarray_similar_type(A, T, NewSize::S, OldSize::S) where {S} = A
-_fieldarray_similar_type(A, T, NewSize, OldSize) =
-    default_similar_type(T, NewSize, length_val(NewSize))
+# We can preserve FieldArrays in array operations which do not change their `Size` and `eltype`.
+# FieldArrays with parametric `eltype` would be adapted to the new `eltype` automatically.
+# Otherwise, we fallback to `S/MArray` based on it's mutability.
+function similar_type(::Type{A}, ::Type{T}, S::Size) where {T,A<:FieldArray}
+    A′ = Base.typeintersect(base_type(A), StaticArray{Tuple{Tuple(S)...},T,length(S)})
+    isabstracttype(A′) || A′ === Union{} || return A′
+    if ismutabletype(A)
+        return mutable_similar_type(T, S, length_val(S))
+    else
+        return default_similar_type(T, S, length_val(S))
+    end
+end
+
+# return `Union{}` for Union Type. Otherwise return the constructor with no parameters.
+@pure base_type(@nospecialize(T::Type)) = (T′ = Base.unwrap_unionall(T); T′ isa DataType ? T′.name.wrapper : Union{})
+if VERSION < v"1.7"
+    @pure ismutabletype(@nospecialize(T::Type)) = (T′ = Base.unwrap_unionall(T); T′ isa DataType && T′.mutable)
+end

test/FieldMatrix.jl

@@ -59,7 +59,6 @@
                 yy::T
             end
 
-            StaticArrays.similar_type(::Type{<:Tensor2x2}, ::Type{T}, s::Size{(2,2)}) where {T} = Tensor2x2{T}
         end)
 
         p = Tensor2x2(0.0, 0.0, 0.0, 0.0)
@@ -83,8 +82,8 @@
 
         @test @inferred(similar_type(Tensor2x2{Float64})) == Tensor2x2{Float64}
         @test @inferred(similar_type(Tensor2x2{Float64}, Float32)) == Tensor2x2{Float32}
-        @test @inferred(similar_type(Tensor2x2{Float64}, Size(3,3))) == SMatrix{3,3,Float64,9}
-        @test @inferred(similar_type(Tensor2x2{Float64}, Float32, Size(4,4))) == SMatrix{4,4,Float32,16}
+        @test @inferred(similar_type(Tensor2x2{Float64}, Size(3, 3))) == MMatrix{3,3,Float64,9}
+        @test @inferred(similar_type(Tensor2x2{Float64}, Float32, Size(4, 4))) == MMatrix{4,4,Float32,16}
 
         # eltype promotion
         @test Tuple(@inferred(Tensor2x2(1., 2, 3, 4f0))) === (1.,2.,3.,4.)

test/FieldVector.jl

@@ -63,7 +63,6 @@
                 y::T
             end
 
-            StaticArrays.similar_type(::Type{<:Point2D}, ::Type{T}, s::Size{(2,)}) where {T} = Point2D{T}
         end)
 
         p = Point2D(0.0, 0.0)
@@ -86,8 +85,8 @@
 
         @test @inferred(similar_type(Point2D{Float64})) == Point2D{Float64}
         @test @inferred(similar_type(Point2D{Float64}, Float32)) == Point2D{Float32}
-        @test @inferred(similar_type(Point2D{Float64}, Size(4))) == SVector{4,Float64}
-        @test @inferred(similar_type(Point2D{Float64}, Float32, Size(4))) == SVector{4,Float32}
+        @test @inferred(similar_type(Point2D{Float64}, Size(4))) == MVector{4,Float64}
+        @test @inferred(similar_type(Point2D{Float64}, Float32, Size(4))) == MVector{4,Float32}
 
         # eltype promotion
         @test Point2D(1f0, 2) isa Point2D{Float32}
@@ -122,7 +121,7 @@
             # No similar_type defined - test fallback codepath
         end)
 
-        @test @inferred(similar_type(FVT{Float64}, Float32)) == SVector{2,Float32} # Fallback code path
+        @test @inferred(similar_type(FVT{Float64}, Float32)) == FVT{Float32}
         @test @inferred(similar_type(FVT{Float64}, Size(2))) == FVT{Float64}
         @test @inferred(similar_type(FVT{Float64}, Size(3))) == SVector{3,Float64}
         @test @inferred(similar_type(FVT{Float64}, Float32, Size(3))) == SVector{3,Float32}