Support for immutable fields derived from AbstractArray

The interface provided by ArrayInterface.jl is now used to check
whether the fields of the structure derived from `DEDataArray` are
immutable. Hence, we can now have fields derived from
`AbstractArray` that are immutable.

Notice that it was required to move the file with the related tests
to the beginning of the set. Since `recursivecopy!` and
`copy_fields!` are both generated functions, then the structure
`Quaternion`, which was created specifically for this test,
together with the definition of the method
`ArrayInterface.ismutable(::Type{<:Quaternion})` must be placed
before the first call to `using DiffEqBase` in the current Julia
session.

Closes #507

Author: ronisbr

src/data_array.jl

@@ -66,7 +66,7 @@ Recursively copy fields of `src` to `dest`.
         Tf = src.types[i]
         qf = Meta.quot(f)
 
-        if Tf <: Union{Number,SArray}
+        if !ArrayInterface.ismutable(Tf)
             expressions[i] = :( dest.$f = getfield( src, $qf ) )
         elseif Tf <: AbstractArray
             expressions[i] = :( recursivecopy!(dest.$f, getfield( src, $qf ) ) )
@@ -110,7 +110,7 @@ end
 
         if f == :x
             expressions[i] = :( )
-        elseif Tf <: Union{Number,SArray}
+        elseif !ArrayInterface.ismutable(Tf)
             expressions[i] = :( dest.$f = getfield( src, $qf ) )
         elseif Tf <: AbstractArray
             expressions[i] = :( recursivecopy!(dest.$f, getfield( src, $qf ) ) )

test/data_array_tests.jl

@@ -1,3 +1,21 @@
+# Note: This must be the first file executed in the tests.
+#
+# The following structure is used to test the problem reported at issue #507. We
+# need to define it here because, since `recursivecopy!` and `copy_fields!` are
+# generated functions, then the `ArrayInterface.isimmutable` method must be
+# defined before the first `using DiffEqBase` in a Julia session.
+
+struct Quaternion{T} <: AbstractVector{T}
+    q0::T
+    q1::T
+    q2::T
+    q3::T
+end
+
+using ArrayInterface
+ArrayInterface.ismutable(::Type{<:Quaternion}) = false
+Base.size(::Quaternion) = 4
+
 using DiffEqBase, RecursiveArrayTools, Test
 
 mutable struct VectorType{T} <: DEDataVector{T}
@@ -105,3 +123,31 @@ end
 s0   = SimWorkspace2{Float64}(SVector{2,Float64}(1.0,4.0),1.)
 s1   = SimWorkspace2{Float64}(SVector{2,Float64}(2.0,1.0),1.)
 s0 .+ s1 == SimWorkspace2{Float64}(SVector{2,Float64}(3.0,5.0),1.)
+
+# Test `recursivecopy!` in immutable structures derived from `AbstractArrays`.
+# See issue #507.
+mutable struct SimWorkspace3{T} <: DEDataVector{T}
+    x::Vector{T}
+    q::Quaternion{T}
+end
+
+a = SimWorkspace3([1.0,2.0,3.0], Quaternion(cosd(15), 0.0, 0.0, sind(15)))
+b = SimWorkspace3([0.0,0.0,0.0], Quaternion(1.0, 0.0, 0.0, 0.0))
+
+recursivecopy!(b,a)
+@test b.x == a.x
+@test b.q.q0 == a.q.q0
+@test b.q.q1 == a.q.q1
+@test b.q.q2 == a.q.q2
+@test b.q.q3 == a.q.q3
+
+a = SimWorkspace3([1.0,2.0,3.0], Quaternion(cosd(15), 0.0, 0.0, sind(15)))
+b = SimWorkspace3([0.0,0.0,0.0], Quaternion(1.0, 0.0, 0.0, 0.0))
+
+DiffEqBase.copy_fields!(b, a)
+@test b.x == [0.0,0.0,0.0]
+@test b.q.q0 == a.q.q0
+@test b.q.q1 == a.q.q1
+@test b.q.q2 == a.q.q2
+@test b.q.q3 == a.q.q3
+

test/runtests.jl

@@ -6,10 +6,10 @@ const is_TRAVIS = haskey(ENV,"TRAVIS")
 
 @time begin
 if GROUP == "All" || GROUP == "Core"
+    @time @safetestset "Data Arrays" begin include("data_array_tests.jl") end
     @time @safetestset "Fast Power" begin include("fastpow.jl") end
     @time @safetestset "Fast Broadcast" begin include("fastbc.jl") end
     @time @safetestset "Number of Parameters Calculation" begin include("numargs_test.jl") end
-    @time @safetestset "Data Arrays" begin include("data_array_tests.jl") end
     @time @safetestset "Existence functions" begin include("existence_functions.jl") end
     @time @safetestset "Callbacks" begin include("callbacks.jl") end
     @time @safetestset "Plot Variables" begin include("plot_vars.jl") end