Put Accumulate filldata! behind a function barrier; Fix stackoverflow/BoundsError issue with cacheddata storing a Vcat+scalar

Author: DanielVandH

src/lazyapplying.jl

@@ -329,6 +329,9 @@ function show(io::IO, A::Applied)
     print(io, ')')
 end
 
+# BroadcastStyle(::Type{<:LinearAlgebra.QRCompactWYQ}) = DefaultArrayStyle{2}()
+# BroadcastStyle(::Type{<:LinearAlgebra.AdjointQ}) = DefaultArrayStyle{2}()
+
 applybroadcaststyle(::Type{<:AbstractArray{<:Any,N}}, _2) where N = DefaultArrayStyle{N}()
 applybroadcaststyle(::Type{<:AbstractArray{<:Any,N}}, ::AbstractLazyLayout) where N = LazyArrayStyle{N}()
 applybroadcaststyle(::Type{<:ApplyArray{<:Any,N,<:Any,Args}}, ::AbstractLazyLayout) where {N,Args<:Tuple} = result_style(LazyArrayStyle{N}(), tuple_type_broadcastlayout(Args))

src/lazyconcat.jl

@@ -256,7 +256,7 @@ function vcat_copyto!(arr::AbstractVector, arrays...)
     i = firstindex(arr)
     for a in arrays
         m = length(a)
-        copyto!(view(arr, range(i, length=m)), a)
+        m > 0 && copyto!(view(arr, range(i, length=m)), a)
         i += m
     end
     arr

src/lazyoperations.jl

@@ -438,25 +438,35 @@ copy(Q::Accumulate) = Accumulate(Q.op, copy(Q.data), copy(Q.v), Q.dims, Q.datasi
 copyto!(x::AbstractArray{<:Any,N}, C::Cumsum{<:Any,N}) where N = cumsum!(x, C.v)
 
 # How we populate the data
-function cache_filldata!(K::Accumulate{<:Any,1}, inds)
-    copyto!(view(K.data,inds), view(K.v,inds))
+function _accumulate_cache_filldata_1d!(data, v, op::F, inds) where {F}
+    copyto!(view(data,inds), view(v,inds))
     @inbounds for k in inds
-        K.data[k] = K.op(K.data[k-1], K.data[k])
+        data[k] = op(data[k-1], v[k])
     end
 end
 
-function cache_filldata!(K::Accumulate{<:Any,2}, kr, jr)
-    if K.dims == 1
+function cache_filldata!(K::Accumulate{<:Any,1}, inds)
+    _accumulate_cache_filldata_1d!(K.data, K.v, K.op, inds)
+end
+
+function _accumulate_cache_filldata_2d!(data, v, op::F, kr, jr, dims) where {F}
+    if dims == 1
+        copyto!(view(data, kr, jr), view(v, kr, jr))
         @inbounds for j in jr, k in kr
-            K.data[k,j] = K.op(K.data[k-1,j], K.v[k,j])
+            data[k,j] = op(data[k-1,j], v[k,j])
         end
-    else # K.dims == 2
+    else # dims == 2
+        copyto!(view(data, kr, jr), view(v, kr, jr))
         @inbounds for j in jr, k in kr
-            K.data[k,j] = K.op(K.data[k,j-1], K.v[k,j])
+            data[k,j] = op(data[k,j-1], v[k,j])
         end
     end
 end
 
+function cache_filldata!(K::Accumulate{<:Any,2}, kr, jr)
+    _accumulate_cache_filldata_2d!(K.data, K.v, K.op, kr, jr, K.dims)
+end
+
 
 # keep lazy
 cumsum(a::LazyArray; kwds...) = Cumsum(a; kwds...)

test/concattests.jl

@@ -729,6 +729,15 @@ import Base.Broadcast: BroadcastStyle
         @test BroadcastStyle(typeof(Vcat())) == LazyArrayStyle{1}() 
         @test BroadcastStyle(typeof(Hcat())) == LazyArrayStyle{2}()
     end
+
+    @testset "Previously broken case with cacheddata storing a Vcat" begin
+        v = Accumulate(*, Vcat(cache(1:3), 5));
+        resizedata!(v, 4)
+        @test v.datasize == (4,)
+        @test v == [1, 2, 6, 30]
+        @test v[4] == 30 
+        @test Base.isassigned(v, 4)
+    end
 end
 
 end # module