Merge branch 'master' into dl/copytosupport

Author: dlfivefifty

src/BlockArrays.jl

@@ -24,7 +24,7 @@ import Base: @propagate_inbounds, Array, to_indices, to_index,
             getindex, ndims, show,
             step,
             broadcast, eltype, convert, similar,
-            @_inline_meta, tail, @_propagate_inbounds_meta, reindex,
+            tail, reindex,
             RangeIndex, Int, Integer, Number,
             +, -, *, /, \, ==, min, max, isless, in, copy, copyto!, axes, @deprecate,
             BroadcastStyle, checkbounds, throw_boundserror,

src/blockaxis.jl

@@ -138,8 +138,7 @@ julia> blockaxes(A,1)
  Block(2)
 ```
 """
-function blockaxes(A::AbstractArray{T,N}, d) where {T,N}
-    @_inline_meta
+@inline function blockaxes(A::AbstractArray{T,N}, d) where {T,N}
     d::Integer <= N ? blockaxes(A)[d] : Base.OneTo(1)
 end
 
@@ -166,7 +165,7 @@ julia> blocksize(A,2)
 """
 blocksize(A) = map(length, blockaxes(A))
 blocksize(A,i) = length(blockaxes(A,i))
-blocklength(t) = (@_inline_meta; prod(blocksize(t)))
+@inline blocklength(t) = prod(blocksize(t))
 
 """
     blocksizes(A)

src/blockdeque.jl

@@ -230,16 +230,19 @@ Base.append!(dest::BlockVector, sources...) = foldl(append!, sources; init = des
 
 Base.append!(dest::BlockVector, src) = append_itr!(dest, Base.IteratorSize(src), src)
 
+@inline function _append_itr_foldfn!(block,i,x)
+    i += 1
+    @inbounds block[i] = x
+    return i
+end
+
 function append_itr!(dest::BlockVector, ::Union{Base.HasShape,Base.HasLength}, src)
     block = dest.blocks[end]
     li = lastindex(block)
     resize!(block, length(block) + length(src))
     # Equivalent to `i = li; for x in src; ...; end` but (maybe) faster:
     foldl(src, init = li) do i, x
-        Base.@_inline_meta
-        i += 1
-        @inbounds block[i] = x
-        return i
+        _append_itr_foldfn!(block,i,x)
     end
     da, = dest.axes
     da.lasts[end] += length(src)

src/pseudo_blockarray.jl

@@ -180,8 +180,8 @@ to_axes(n::Integer) = Base.oneto(n)
 @inline Base.similar(block_array::PseudoBlockArray, ::Type{T}, axes::Tuple{Union{Integer,AbstractUnitRange{Int}},BlockedUnitRange,Vararg{Union{Integer,AbstractUnitRange{Int}}}}) where T =
     PseudoBlockArray{T}(undef, map(to_axes,axes))
 
-@inline Base.@propagate_inbounds Base.getindex(block_arr::PseudoBlockArray{T, N}, i::Vararg{Integer, N}) where {T,N} = block_arr.blocks[i...]
-@inline Base.@propagate_inbounds Base.setindex!(block_arr::PseudoBlockArray{T, N}, v, i::Vararg{Integer, N}) where {T,N} = setindex!(block_arr.blocks, v, i...)
+@inline @propagate_inbounds Base.getindex(block_arr::PseudoBlockArray{T, N}, i::Vararg{Integer, N}) where {T,N} = block_arr.blocks[i...]
+@inline @propagate_inbounds Base.setindex!(block_arr::PseudoBlockArray{T, N}, v, i::Vararg{Integer, N}) where {T,N} = setindex!(block_arr.blocks, v, i...)
 
 ################################
 # AbstractBlockArray Interface #
@@ -197,7 +197,7 @@ to_axes(n::Integer) = Base.oneto(n)
     return view(block_arr.blocks, range...)
 end
 
-@inline Base.@propagate_inbounds function _pseudoblockindex_getindex(block_arr, blockindex)
+@inline @propagate_inbounds function _pseudoblockindex_getindex(block_arr, blockindex)
     I = getindex.(axes(block_arr), getindex.(Block.(blockindex.I), blockindex.α))
     block_arr.blocks[I...]
 end

src/views.jl

@@ -44,74 +44,69 @@ to_index(::BlockRange) = throw(ArgumentError("BlockRange must be converted by to
 @inline to_indices(A, I::Tuple{Block, Vararg{Any}}) = to_indices(A, axes(A), I)
 @inline to_indices(A, I::Tuple{BlockRange, Vararg{Any}}) = to_indices(A, axes(A), I)
 
-reindex(idxs::Tuple{BlockSlice{<:BlockRange}, Vararg{Any}},
+@propagate_inbounds reindex(idxs::Tuple{BlockSlice{<:BlockRange}, Vararg{Any}},
         subidxs::Tuple{BlockSlice{<:BlockIndexRange}, Vararg{Any}}) =
-    (@_propagate_inbounds_meta; (BlockSlice(BlockIndexRange(Block(idxs[1].block.indices[1][Int(subidxs[1].block.block)]),
+    (BlockSlice(BlockIndexRange(Block(idxs[1].block.indices[1][Int(subidxs[1].block.block)]),
                                                             subidxs[1].block.indices),
                                             idxs[1].indices[subidxs[1].indices]),
-                                reindex(tail(idxs), tail(subidxs))...))
-reindex(idxs::Tuple{BlockSlice{<:BlockRange}, Vararg{Any}},
+                                reindex(tail(idxs), tail(subidxs))...)
+@propagate_inbounds reindex(idxs::Tuple{BlockSlice{<:BlockRange}, Vararg{Any}},
         subidxs::Tuple{BlockSlice{<:Block}, Vararg{Any}}) =
-    (@_propagate_inbounds_meta; (BlockSlice(idxs[1].block[Int(subidxs[1].block)],
+    (BlockSlice(idxs[1].block[Int(subidxs[1].block)],
                                             idxs[1].indices[subidxs[1].indices]),
-                                reindex(tail(idxs), tail(subidxs))...))
+                                reindex(tail(idxs), tail(subidxs))...)
 
-reindex(idxs::Tuple{BlockedUnitRange, Vararg{Any}},
+@propagate_inbounds reindex(idxs::Tuple{BlockedUnitRange, Vararg{Any}},
         subidxs::Tuple{BlockSlice{<:Block}, Vararg{Any}}) =
-    (@_propagate_inbounds_meta; (BlockSlice(subidxs[1].block,
+    (BlockSlice(subidxs[1].block,
                                             idxs[1][subidxs[1].block]),
-                                reindex(tail(idxs), tail(subidxs))...))
+                                reindex(tail(idxs), tail(subidxs))...)
 # _splatmap taken from Base:
 _splatmap(f, ::Tuple{}) = ()
 _splatmap(f, t::Tuple) = (f(t[1])..., _splatmap(f, tail(t))...)
 
 # De-reference blocks before creating a view to avoid taking `global2blockindex`
 # path in `AbstractBlockStyle` broadcasting.
-@inline function Base.unsafe_view(
+@propagate_inbounds function Base.unsafe_view(
         A::BlockArray{<:Any, N},
         I::Vararg{BlockSlice{<:BlockIndexRange{1}}, N}) where {N}
-    @_propagate_inbounds_meta
     B = view(A, map(block, I)...)
     return view(B, _splatmap(x -> x.block.indices, I)...)
 end
 
-@inline function Base.unsafe_view(
+@propagate_inbounds function Base.unsafe_view(
         A::PseudoBlockArray{<:Any, N},
         I::Vararg{BlockSlice{<:BlockIndexRange{1}}, N}) where {N}
-    @_propagate_inbounds_meta
     return view(A.blocks, map(x -> x.indices, I)...)
 end
 
-@inline function Base.unsafe_view(
+@propagate_inbounds  function Base.unsafe_view(
         A::ReshapedArray{<:Any, N, <:AbstractBlockArray{<:Any, M}},
         I::Vararg{BlockSlice{<:BlockIndexRange{1}}, N}) where {N, M}
-    @_propagate_inbounds_meta
     # Note: assuming that I[M+1:end] are verified to be singletons
     return reshape(view(A.parent, I[1:M]...), Val(N))
 end
 
-@inline function Base.unsafe_view(
+@propagate_inbounds  function Base.unsafe_view(
         A::Array{<:Any, N},
         I::Vararg{BlockSlice{<:BlockIndexRange{1}}, N}) where {N}
-    @_propagate_inbounds_meta
     return view(A, map(x -> x.indices, I)...)
 end
 
 # make sure we reindex correctrly
-function Base._maybe_reindex(V, I::Tuple{BlockSlice{<:BlockIndexRange{1}}, Vararg{Any}}, ::Tuple{})
-    @_inline_meta
+@inline function Base._maybe_reindex(V, I::Tuple{BlockSlice{<:BlockIndexRange{1}}, Vararg{Any}}, ::Tuple{})
     @inbounds idxs = to_indices(V.parent, reindex(V.indices, I))
     view(V.parent, idxs...)
 end
 
 
 # BlockSlices map the blocks and the indices
 # this is loosely based on Slice reindex in subarray.jl
-reindex(idxs::Tuple{BlockSlice{<:BlockRange}, Vararg{Any}},
+@propagate_inbounds reindex(idxs::Tuple{BlockSlice{<:BlockRange}, Vararg{Any}},
         subidxs::Tuple{BlockSlice{<:BlockRange}, Vararg{Any}}) =
-    (@_propagate_inbounds_meta; (BlockSlice(BlockRange(idxs[1].block.indices[1][Int.(subidxs[1].block)]),
+    (BlockSlice(BlockRange(idxs[1].block.indices[1][Int.(subidxs[1].block)]),
                                             idxs[1].indices[subidxs[1].block]),
-                                reindex(tail(idxs), tail(subidxs))...))
+                                reindex(tail(idxs), tail(subidxs))...)
 
 
 function reindex(idxs::Tuple{BlockSlice{Block{1,Int}}, Vararg{Any}},