refactor: promote types in remake_buffer instead of Union

Author: AayushSabharwal

src/remake.jl

@@ -6,8 +6,8 @@ are symbolic variables whose index in the buffer is determined using `sys`. The
 values in `vals` may not match the types of values stored at the corresponding indexes in
 the buffer, in which case the type of the buffer should be promoted accordingly. In
 general, this method should attempt to preserve the types of values stored in `vals` as
-much as possible. The returned buffer should be of the same type (ignoring type-parameters)
-as `oldbuffer`.
+much as possible. Types can be promoted for type-stability, to maintain performance. The
+returned buffer should be of the same type (ignoring type-parameters) as `oldbuffer`.
 
 This method is already implemented for
 `remake_buffer(sys, oldbuffer::AbstractArray, vals::Dict)` and supports static arrays
@@ -19,11 +19,11 @@ function remake_buffer(sys, oldbuffer::AbstractArray, vals::Dict)
     if ArrayInterface.ismutable(oldbuffer) && !isa(oldbuffer, MArray)
         elT = Union{}
         for val in values(vals)
-            elT = Union{elT, typeof(val)}
+            elT = promote_type(elT, typeof(val))
         end
 
         newbuffer = similar(oldbuffer, elT)
-        setu(sys, collect(keys(vals)))(newbuffer, values(vals))
+        setu(sys, collect(keys(vals)))(newbuffer, elT.(values(vals)))
     else
         mutbuffer = remake_buffer(sys, collect(oldbuffer), vals)
         newbuffer = similar_type(oldbuffer, eltype(mutbuffer))(mutbuffer)

test/remake_test.jl

@@ -7,26 +7,26 @@ for (buf, newbuf, newvals) in [
                                # standard operation
                                ([1.0, 2.0, 3.0], [2.0, 3.0, 4.0],
                                    Dict(:x => 2.0, :y => 3.0, :z => 4.0))
-                               # type "demotion"
+                               # buffer type "demotion"
                                ([1.0, 2.0, 3.0], [2, 3, 4],
                                    Dict(:x => 2, :y => 3, :z => 4))
-                               # type promotion
+                               # buffer type promotion
                                ([1, 2, 3], [2.0, 3.0, 4.0],
                                    Dict(:x => 2.0, :y => 3.0, :z => 4.0))
-                               # union
-                               ([1, 2, 3], Union{Int, Float64}[2, 3.0, 4.0],
+                               # value type promotion
+                               ([1, 2, 3], [2.0, 3.0, 4.0],
                                    Dict(:x => 2, :y => 3.0, :z => 4.0))
                                # standard operation
                                ([1.0, 2.0, 3.0], [2.0, 3.0, 4.0],
                                    Dict(:a => 2.0, :b => 3.0, :c => 4.0))
-                               # type "demotion"
+                               # buffer type "demotion"
                                ([1.0, 2.0, 3.0], [2, 3, 4],
                                    Dict(:a => 2, :b => 3, :c => 4))
-                               # type promotion
+                               # buffer type promotion
                                ([1, 2, 3], [2.0, 3.0, 4.0],
                                    Dict(:a => 2.0, :b => 3.0, :c => 4.0))
-                               # union
-                               ([1, 2, 3], Union{Int, Float64}[2, 3.0, 4.0],
+                               # value type promotion
+                               ([1, 2, 3], [2, 3.0, 4.0],
                                    Dict(:a => 2, :b => 3.0, :c => 4.0))]
     for arrType in [Vector, SVector{3}, MVector{3}, SizedVector{3}]
         buf = arrType(buf)