Merge branch 'master' into subarrayofadjointvector

Author: chriselrod

Project.toml

@@ -1,6 +1,6 @@
 name = "ArrayInterface"
 uuid = "4fba245c-0d91-5ea0-9b3e-6abc04ee57a9"
-version = "5.0.1"
+version = "5.0.5"
 
 [deps]
 Compat = "34da2185-b29b-5c13-b0c7-acf172513d20"

src/ArrayInterface.jl

@@ -13,6 +13,8 @@ import Compat
 using Base: @propagate_inbounds, tail, OneTo, LogicalIndex, Slice, ReinterpretArray,
     ReshapedArray, AbstractCartesianIndex
 
+using Base.Iterators: Pairs
+
 const CanonicalInt = Union{Int,StaticInt}
 canonicalize(x::Integer) = Int(x)
 canonicalize(@nospecialize(x::StaticInt)) = x
@@ -187,6 +189,11 @@ Query whether a type can use `setindex!`.
 can_setindex(x) = can_setindex(typeof(x))
 can_setindex(::Type) = true
 can_setindex(::Type{<:AbstractRange}) = false
+can_setindex(::Type{<:AbstractDict}) = true
+can_setindex(::Type{<:Base.ImmutableDict}) = false
+can_setindex(@nospecialize T::Type{<:Tuple}) = false
+can_setindex(@nospecialize T::Type{<:NamedTuple}) = false
+can_setindex(::Type{<:Pairs{<:Any,<:Any,P}}) where {P} = can_setindex(P)
 
 """
     aos_to_soa(x)

src/dimensions.jl

@@ -147,17 +147,15 @@ function to_parent_dims(::Type{T}, ::StaticInt{dim}) where {T,dim}
     end
 end
 
-_nunderscore(::Val{N}) where {N} = ntuple(Compat.Returns(:_), Val(N))
-
 """
     has_dimnames(::Type{T}) -> StaticBool
 
 Returns `static(true)` if `x` has on or more named dimensions. If all dimensions correspond
 to `static(:_)`, then `static(false)` is returned.
 """
-Compat.@constprop :aggressive has_dimnames(x) = static(_is_named(known_dimnames(x)))
-_is_named(x::NTuple{N,Symbol}) where {N} = x !== _nunderscore(Val(N))
-_is_named(::Any) = true
+@inline function has_dimnames(x)
+    static(known_dimnames(x) !== ntuple(Compat.Returns(:_), Val(ndims(x))))
+end
 
 """
     known_dimnames(::Type{T}) -> Tuple{Vararg{Union{Symbol,Nothing}}}
@@ -170,7 +168,7 @@ have a name.
 known_dimnames(x) = known_dimnames(typeof(x))
 known_dimnames(::Type{T}) where {T} = _known_dimnames(T, parent_type(T))
 _known_dimnames(::Type{T}, ::Type{T}) where {T} = _unknown_dimnames(Base.IteratorSize(T))
-_unknown_dimnames(::Base.HasShape{N}) where {N} = _nunderscore(Val(N))
+_unknown_dimnames(::Base.HasShape{N}) where {N} = ntuple(Compat.Returns(:_), Val(N))
 _unknown_dimnames(::Any) = (:_,)
 function _known_dimnames(::Type{C}, ::Type{P}) where {C,P}
     eachop(_inbounds_known_dimname, to_parent_dims(C), known_dimnames(P))

src/ranges.jl

@@ -482,3 +482,19 @@ Returns valid indices for array `x` along each dimension specified in `dim`.
 _indices(x, dims::Tuple) = (indices(x, first(dims)), _indices(x, tail(dims))...)
 _indices(x, ::Tuple{}) = ()
 
+function Base.Broadcast.axistype(r::OptionallyStaticUnitRange{StaticInt{1}}, _)
+  Base.OneTo(last(r))
+end
+function Base.Broadcast.axistype(_, r::OptionallyStaticUnitRange{StaticInt{1}})
+  Base.OneTo(last(r))
+end
+function Base.Broadcast.axistype(r::OptionallyStaticUnitRange{StaticInt{1}}, ::OptionallyStaticUnitRange{StaticInt{1}})
+  Base.OneTo(last(r))
+end
+function Base.similar(::Type{<:Array{T}}, axes::Tuple{OptionallyStaticUnitRange{StaticInt{1}},Vararg{Union{Base.OneTo,OptionallyStaticUnitRange{StaticInt{1}}}}}) where {T}
+  Array{T}(undef, map(last, axes))
+end
+function Base.similar(::Type{<:Array{T}}, axes::Tuple{Base.OneTo,OptionallyStaticUnitRange{StaticInt{1}},Vararg{Union{Base.OneTo,OptionallyStaticUnitRange{StaticInt{1}}}}}) where {T}
+  Array{T}(undef, map(last, axes))
+end
+

src/stridelayout.jl

@@ -117,7 +117,7 @@ function contiguous_axis(::Type{T}) where {T}
         return contiguous_axis(parent_type(T))
     end
 end
-contiguous_axis(::Type{<:Array}) = One()
+contiguous_axis(::Type{<:DenseArray}) = One()
 contiguous_axis(::Type{<:BitArray}) = One()
 contiguous_axis(::Type{<:AbstractRange}) = One()
 contiguous_axis(::Type{<:Tuple}) = One()
@@ -220,7 +220,7 @@ function stride_rank(::Type{T}) where {T}
         return stride_rank(parent_type(T))
     end
 end
-stride_rank(::Type{Array{T,N}}) where {T,N} = nstatic(Val(N))
+stride_rank(::Type{<:DenseArray{T,N}}) where {T,N} = nstatic(Val(N))
 stride_rank(::Type{BitArray{N}}) where {N} = nstatic(Val(N))
 stride_rank(::Type{<:AbstractRange}) = (One(),)
 stride_rank(::Type{<:Tuple}) = (One(),)

test/ranges.jl

@@ -118,6 +118,12 @@
     @test @inferred(eachindex(static(-7):static(7))) === static(1):static(15)
     @test @inferred((static(-7):static(7))[first(eachindex(static(-7):static(7)))]) == -7
 
-    @test @inferred(firstindex(128:static(-1):1)) == 1
+  @test @inferred(firstindex(128:static(-1):1)) == 1
+
+  @test identity.(static(1):5) isa Vector{Int}
+  @test (static(1):5) .+ (1:3)' isa Matrix{Int}
+  @test similar(Array{Int}, (static(1):(4),)) isa Vector{Int}
+  @test similar(Array{Int}, (static(1):(4), Base.OneTo(4))) isa Matrix{Int}
+  @test similar(Array{Int}, (Base.OneTo(4), static(1):(4))) isa Matrix{Int}
 end
 

test/runtests.jl

@@ -72,6 +72,10 @@ end
     @test !@inferred(ArrayInterface.can_setindex(1:2))
     @test @inferred(ArrayInterface.can_setindex(Vector{Int}))
     @test !@inferred(ArrayInterface.can_setindex(UnitRange{Int}))
+    @test !@inferred(ArrayInterface.can_setindex(Base.ImmutableDict{Int,Int}))
+    @test !@inferred(ArrayInterface.can_setindex(Tuple{}))
+    @test !@inferred(ArrayInterface.can_setindex(NamedTuple{(),Tuple{}}))
+    @test @inferred(ArrayInterface.can_setindex(Dict{Int,Int}))
 end
 
 @testset "ArrayInterface.isstructured" begin