Fixup with latest ImmutableArrays changes

Author: Ian Atol

base/abstractarray.jl

@@ -1085,6 +1085,8 @@ function copy(a::AbstractArray)
     copymutable(a)
 end
 
+copy(a::Core.ImmutableArray) = a
+
 function copyto!(B::AbstractVecOrMat{R}, ir_dest::AbstractRange{Int}, jr_dest::AbstractRange{Int},
                A::AbstractVecOrMat{S}, ir_src::AbstractRange{Int}, jr_src::AbstractRange{Int}) where {R,S}
     if length(ir_dest) != length(ir_src)

base/array.jl

@@ -118,6 +118,36 @@ Union type of [`DenseVector{T}`](@ref) and [`DenseMatrix{T}`](@ref).
 """
 const DenseVecOrMat{T} = Union{DenseVector{T}, DenseMatrix{T}}
 
+"""
+    ImmutableArray{T,N} <: AbstractArray{T,N}
+Dynamically allocated, immutable array.
+"""
+const ImmutableArray = Core.ImmutableArray
+
+"""
+    ImmutableVector{T} <: AbstractVector{T}
+Dynamically allocated, immutable vector.
+"""
+const ImmutableVector{T} = ImmutableArray{T,1}
+
+"""
+    IMArray{T,N}
+Union type of [`Array{T,N}`](@ref) and [`ImmutableArray{T,N}`](@ref)
+"""
+const IMArray{T,N} = Union{Array{T, N}, ImmutableArray{T,N}}
+
+"""
+    IMVector{T}
+One-dimensional [`ImmutableArray`](@ref) or [`Array`](@ref) with elements of type `T`. Alias for `IMArray{T, 1}`.
+"""
+const IMVector{T} = IMArray{T, 1}
+
+"""
+    IMMatrix{T}
+Two-dimensional [`ImmutableArray`](@ref) or [`Array`](@ref) with elements of type `T`. Alias for `IMArray{T,2}`.
+"""
+const IMMatrix{T} = IMArray{T, 2}
+
 ## Basic functions ##
 
 import Core: arraysize, arrayset, arrayref, const_arrayref
@@ -147,18 +177,13 @@ function vect(X...)
     return copyto!(Vector{T}(undef, length(X)), X)
 end
 
-const ImmutableArray = Core.ImmutableArray
-const IMArray{T,N} = Union{Array{T, N}, ImmutableArray{T,N}}
-const IMVector{T} = IMArray{T, 1}
-const IMMatrix{T} = IMArray{T, 2}
-
 ImmutableArray(a::Array) = Core.arrayfreeze(a)
 Array(a::ImmutableArray) = Core.arraythaw(a)
 
 size(a::IMArray, d::Integer) = arraysize(a, convert(Int, d))
 size(a::IMVector) = (arraysize(a,1),)
 size(a::IMMatrix) = (arraysize(a,1), arraysize(a,2))
-size(a::IMArray{<:Any,N}) where {N} = (@_inline_meta; ntuple(M -> size(a, M), Val(N))::Dims)
+size(a::IMArray{<:Any,N}) where {N} = (@inline; ntuple(M -> size(a, M), Val(N))::Dims)
 
 asize_from(a::IMArray, n) = n > ndims(a) ? () : (arraysize(a,n), asize_from(a, n+1)...)
 
@@ -220,24 +245,17 @@ function bitsunionsize(u::Union)
     return sz
 end
 
-length(a::Array) = arraylen(a)
+length(a::IMArray) = arraylen(a)
 elsize(@nospecialize _::Type{A}) where {T,A<:Array{T}} = aligned_sizeof(T)
-sizeof(a::Array) = Core.sizeof(a)
+sizeof(a::IMArray) = Core.sizeof(a)
 
-function isassigned(a::Array, i::Int...)
+function isassigned(a::IMArray, i::Int...)
     @inline
     ii = (_sub2ind(size(a), i...) % UInt) - 1
     @boundscheck ii < length(a) % UInt || return false
     ccall(:jl_array_isassigned, Cint, (Any, UInt), a, ii) == 1
 end
 
-function isassigned(a::ImmutableArray, i::Int...)
-    @_inline_meta
-    ii = (_sub2ind(size(a), i...) % UInt) - 1
-    @boundscheck ii < length(a) % UInt || return false
-    ccall(:jl_array_isassigned, Cint, (Any, UInt), a, ii) == 1
-end
-
 ## copy ##
 
 """
@@ -626,7 +644,7 @@ oneunit(x::AbstractMatrix{T}) where {T} = _one(oneunit(T), x)
 
 ## Conversions ##
 
-convert(::Type{T}, a::AbstractArray) where {T<:Array} = a isa T ? a : T(a)
+convert(T::Type{<:IMArray}, a::AbstractArray) = a isa T ? a : T(a)
 convert(::Type{Union{}}, a::AbstractArray) = throw(MethodError(convert, (Union{}, a)))
 
 promote_rule(a::Type{Array{T,n}}, b::Type{Array{S,n}}) where {T,n,S} = el_same(promote_type(T,S), a, b)
@@ -637,6 +655,7 @@ if nameof(@__MODULE__) === :Base  # avoid method overwrite
 # constructors should make copies
 Array{T,N}(x::AbstractArray{S,N})         where {T,N,S} = copyto_axcheck!(Array{T,N}(undef, size(x)), x)
 AbstractArray{T,N}(A::AbstractArray{S,N}) where {T,N,S} = copyto_axcheck!(similar(A,T), A)
+ImmutableArray{T,N}(Ar::AbstractArray{S,N}) where {T,N,S} = Core.arrayfreeze(copyto_axcheck!(Array{T,N}(undef, size(Ar)), Ar))
 end
 
 ## copying iterators to containers
@@ -937,7 +956,7 @@ function getindex end
 @eval getindex(A::Array, i1::Int, i2::Int, I::Int...) = (@inline; arrayref($(Expr(:boundscheck)), A, i1, i2, I...))
 
 @eval getindex(A::ImmutableArray, i1::Int) = arrayref($(Expr(:boundscheck)), A, i1)
-@eval getindex(A::ImmutableArray, i1::Int, i2::Int, I::Int...) = (@_inline_meta; arrayref($(Expr(:boundscheck)), A, i1, i2, I...))
+@eval getindex(A::ImmutableArray, i1::Int, i2::Int, I::Int...) = (@inline; arrayref($(Expr(:boundscheck)), A, i1, i2, I...))
 
 # Faster contiguous indexing using copyto! for UnitRange and Colon
 function getindex(A::Array, I::AbstractUnitRange{<:Integer})

base/broadcast.jl

@@ -1345,4 +1345,17 @@ function Base.show(io::IO, op::BroadcastFunction)
 end
 Base.show(io::IO, ::MIME"text/plain", op::BroadcastFunction) = show(io, op)
 
+struct IMArrayStyle <: Broadcast.AbstractArrayStyle{Any} end
+BroadcastStyle(::Type{<:Core.ImmutableArray}) = IMArrayStyle()
+
+#similar has to return mutable array
+function Base.similar(bc::Broadcasted{IMArrayStyle}, ::Type{ElType}) where ElType
+    similar(Array{ElType}, axes(bc))
+end
+
+@inline function copy(bc::Broadcasted{IMArrayStyle})
+    ElType = combine_eltypes(bc.f, bc.args)
+    return Core.ImmutableArray(copyto!(similar(bc, ElType), bc))
+end
+
 end # module

base/compiler/ssair/EscapeAnalysis/EscapeAnalysis.jl

@@ -1608,7 +1608,7 @@ function escape_builtin!(::typeof(arrayref), astate::AnalysisState, pc::Int, arg
     argtypes = Any[argextype(args[i], astate.ir) for i in 2:length(args)]
     boundcheckt = argtypes[1]
     aryt = argtypes[2]
-    if !array_builtin_common_typecheck(boundcheckt, aryt, argtypes, 3)
+    if !array_builtin_common_typecheck(Array, boundcheckt, aryt, argtypes, 3)
         add_thrown_escapes!(astate, pc, args, 2)
     end
     ary = args[3]
@@ -1670,7 +1670,7 @@ function escape_builtin!(::typeof(arrayset), astate::AnalysisState, pc::Int, arg
     boundcheckt = argtypes[1]
     aryt = argtypes[2]
     valt = argtypes[3]
-    if !(array_builtin_common_typecheck(boundcheckt, aryt, argtypes, 4) &&
+    if !(array_builtin_common_typecheck(Array, boundcheckt, aryt, argtypes, 4) &&
          arrayset_typecheck(aryt, valt))
         add_thrown_escapes!(astate, pc, args, 2)
     end

base/compiler/tfuncs.jl

@@ -461,8 +461,10 @@ add_tfunc(Core._typevar, 3, 3, typevar_tfunc, 100)
 add_tfunc(applicable, 1, INT_INF, (@nospecialize(f), args...)->Bool, 100)
 add_tfunc(Core.Intrinsics.arraylen, 1, 1, @nospecialize(x)->Int, 4)
 
+const Arrayish = Union{Array,ImmutableArray}
+
 function arraysize_tfunc(@nospecialize(ary), @nospecialize(dim))
-    hasintersect(widenconst(ary), Array) || return Bottom
+    hasintersect(widenconst(ary), Arrayish) || return Bottom
     hasintersect(widenconst(dim), Int) || return Bottom
     return Int
 end
@@ -472,7 +474,7 @@ function arraysize_nothrow(argtypes::Vector{Any})
     length(argtypes) == 2 || return false
     ary = argtypes[1]
     dim = argtypes[2]
-    ary ⊑ Array || return false
+    widenconst(ary) <: Arrayish || return false
     if isa(dim, Const)
         dimval = dim.val
         return isa(dimval, Int) && dimval > 0
@@ -1535,27 +1537,27 @@ function tuple_tfunc(argtypes::Vector{Any})
 end
 
 arrayref_tfunc(@nospecialize(boundscheck), @nospecialize(ary), @nospecialize idxs...) =
-    _arrayref_tfunc(boundscheck, ary, idxs)
-function _arrayref_tfunc(@nospecialize(boundscheck), @nospecialize(ary),
-    @nospecialize idxs::Tuple)
+    _arrayref_tfunc(Arrayish, boundscheck, ary, idxs)
+function _arrayref_tfunc(@nospecialize(Arytype), 
+    @nospecialize(boundscheck), @nospecialize(ary), @nospecialize idxs::Tuple)
     isempty(idxs) && return Bottom
-    array_builtin_common_errorcheck(boundscheck, ary, idxs) || return Bottom
-    return array_elmtype(ary)
+    array_builtin_common_errorcheck(Arytype, boundscheck, ary, idxs) || return Bottom
+    return array_elmtype(Arytype, ary)
 end
 add_tfunc(arrayref, 3, INT_INF, arrayref_tfunc, 20)
 add_tfunc(const_arrayref, 3, INT_INF, arrayref_tfunc, 20)
 
 function arrayset_tfunc(@nospecialize(boundscheck), @nospecialize(ary), @nospecialize(item),
     @nospecialize idxs...)
-    hasintersect(widenconst(item), _arrayref_tfunc(boundscheck, ary, idxs)) || return Bottom
+    hasintersect(widenconst(item), _arrayref_tfunc(Array, boundscheck, ary, idxs)) || return Bottom
     return ary
 end
 add_tfunc(arrayset, 4, INT_INF, arrayset_tfunc, 20)
 
-function array_builtin_common_errorcheck(@nospecialize(boundscheck), @nospecialize(ary),
-    @nospecialize idxs::Tuple)
+function array_builtin_common_errorcheck(@nospecialize(Arytype),
+    @nospecialize(boundscheck), @nospecialize(ary), @nospecialize idxs::Tuple)
     hasintersect(widenconst(boundscheck), Bool) || return false
-    hasintersect(widenconst(ary), Array) || return false
+    hasintersect(widenconst(ary), Arytype) || return false
     for i = 1:length(idxs)
         idx = getfield(idxs, i)
         idx = isvarargtype(idx) ? unwrapva(idx) : widenconst(idx)
@@ -1564,9 +1566,9 @@ function array_builtin_common_errorcheck(@nospecialize(boundscheck), @nospeciali
     return true
 end
 
-function array_elmtype(@nospecialize ary)
+function array_elmtype(@nospecialize(Arytype), @nospecialize ary)
     a = widenconst(ary)
-    if !has_free_typevars(a) && a <: Array
+    if !has_free_typevars(a) && a <: Arytype
         a0 = a
         if isa(a, UnionAll)
             a = unwrap_unionall(a0)
@@ -1580,6 +1582,32 @@ function array_elmtype(@nospecialize ary)
     return Any
 end
 
+# the ImmutableArray operations might involve copies and so their computation costs can be high,
+# nevertheless we assign smaller inlining costs to them here, since the escape analysis
+# at this moment isn't able to propagate array escapes interprocedurally
+# and it will fail to optimize most cases without inlining
+
+arrayfreeze_tfunc(@nospecialize a) = immutable_array_tfunc(Array, ImmutableArray, a)
+add_tfunc(Core.arrayfreeze, 1, 1, arrayfreeze_tfunc, 20)
+
+mutating_arrayfreeze_tfunc(@nospecialize a) = immutable_array_tfunc(Array, ImmutableArray, a)
+add_tfunc(Core.mutating_arrayfreeze, 1, 1, mutating_arrayfreeze_tfunc, 10)
+
+arraythaw_tfunc(@nospecialize a) = immutable_array_tfunc(ImmutableArray, Array, a)
+add_tfunc(Core.arraythaw, 1, 1, arraythaw_tfunc, 20)
+
+function immutable_array_tfunc(@nospecialize(at), @nospecialize(rt), @nospecialize(a))
+    a = widenconst(a)
+    hasintersect(a, at) || return Bottom
+    if a <: at
+        unw = unwrap_unionall(a)
+        if isa(unw, DataType)
+            return rewrap_unionall(rt{unw.parameters[1], unw.parameters[2]}, a)
+        end
+    end
+    return rt
+end
+
 function _opaque_closure_tfunc(@nospecialize(arg), @nospecialize(isva),
         @nospecialize(lb), @nospecialize(ub), @nospecialize(source), env::Vector{Any},
         linfo::MethodInstance)
@@ -1613,11 +1641,12 @@ function array_type_undefable(@nospecialize(arytype))
     end
 end
 
-function array_builtin_common_nothrow(argtypes::Vector{Any}, first_idx_idx::Int)
+function array_builtin_common_nothrow(@nospecialize(Arytype),
+    argtypes::Vector{Any}, first_idx_idx::Int)
     length(argtypes) >= 4 || return false
     boundscheck = argtypes[1]
     arytype = argtypes[2]
-    array_builtin_common_typecheck(boundscheck, arytype, argtypes, first_idx_idx) || return false
+    array_builtin_common_typecheck(Arytype, boundscheck, arytype, argtypes, first_idx_idx) || return false
     # If we could potentially throw undef ref errors, bail out now.
     arytype = widenconst(arytype)
     array_type_undefable(arytype) && return false
@@ -1632,12 +1661,12 @@ function array_builtin_common_nothrow(argtypes::Vector{Any}, first_idx_idx::Int)
     return false
 end
 
-function array_builtin_common_typecheck(
+function array_builtin_common_typecheck(@nospecialize(Arytype),
     @nospecialize(boundscheck), @nospecialize(arytype),
     argtypes::Vector{Any}, first_idx_idx::Int)
-    (boundscheck ⊑ Bool && arytype ⊑ Array) || return false
+    (widenconst(boundscheck) <: Bool && widenconst(arytype) <: Arytype) || return false
     for i = first_idx_idx:length(argtypes)
-        argtypes[i] ⊑ Int || return false
+        widenconst(argtypes[i]) <: Int || return false
     end
     return true
 end
@@ -1656,11 +1685,11 @@ end
 # Query whether the given builtin is guaranteed not to throw given the argtypes
 function _builtin_nothrow(@nospecialize(f), argtypes::Array{Any,1}, @nospecialize(rt))
     if f === arrayset
-        array_builtin_common_nothrow(argtypes, 4) || return true
+        array_builtin_common_nothrow(Array, argtypes, 4) || return true
         # Additionally check element type compatibility
         return arrayset_typecheck(argtypes[2], argtypes[3])
     elseif f === arrayref || f === const_arrayref
-        return array_builtin_common_nothrow(argtypes, 3)
+        return array_builtin_common_nothrow(Arrayish, argtypes, 3)
     elseif f === arraysize
         return arraysize_nothrow(argtypes)
     elseif f === Core._expr
@@ -1818,8 +1847,7 @@ function builtin_tfunction(interp::AbstractInterpreter, @nospecialize(f), argtyp
             end
         end
         return rt
-    end
-    if isa(f, IntrinsicFunction)
+    elseif isa(f, IntrinsicFunction)
         if is_pure_intrinsic_infer(f) && _all(@nospecialize(a) -> isa(a, Const), argtypes)
             argvals = anymap(@nospecialize(a) -> (a::Const).val, argtypes)
             try

base/compiler/types.jl

@@ -261,7 +261,7 @@ struct NativeInterpreter <: AbstractInterpreter
         end
 
         # If they didn't pass typemax(UInt) but passed something more subtly
-        # incorrect, fail out loudly.
+        # incorrect, fail out loud.
         @assert world <= get_world_counter()
 
 

base/exports.jl

@@ -22,6 +22,7 @@ export
     AbstractVector,
     AbstractVecOrMat,
     Array,
+    ImmutableArray,
     AbstractMatch,
     AbstractPattern,
     AbstractDict,
@@ -96,6 +97,7 @@ export
     Val,
     VecOrMat,
     Vector,
+    ImmutableVector,
     VersionNumber,
     WeakKeyDict,
 

base/indices.jl

@@ -95,6 +95,7 @@ IndexStyle(A::AbstractArray) = IndexStyle(typeof(A))
 IndexStyle(::Type{Union{}}) = IndexLinear()
 IndexStyle(::Type{<:AbstractArray}) = IndexCartesian()
 IndexStyle(::Type{<:Array}) = IndexLinear()
+IndexStyle(::Type{<:Core.ImmutableArray}) = IndexLinear()
 IndexStyle(::Type{<:AbstractRange}) = IndexLinear()
 
 IndexStyle(A::AbstractArray, B::AbstractArray) = IndexStyle(IndexStyle(A), IndexStyle(B))

base/pointer.jl

@@ -63,6 +63,7 @@ cconvert(::Type{Ptr{UInt8}}, s::AbstractString) = String(s)
 cconvert(::Type{Ptr{Int8}}, s::AbstractString) = String(s)
 
 unsafe_convert(::Type{Ptr{T}}, a::Array{T}) where {T} = ccall(:jl_array_ptr, Ptr{T}, (Any,), a)
+unsafe_convert(::Type{Ptr{T}}, a::Core.ImmutableArray{T}) where {T} = ccall(:jl_array_ptr, Ptr{T}, (Any,), a)
 unsafe_convert(::Type{Ptr{S}}, a::AbstractArray{T}) where {S,T} = convert(Ptr{S}, unsafe_convert(Ptr{T}, a))
 unsafe_convert(::Type{Ptr{T}}, a::AbstractArray{T}) where {T} = error("conversion to pointer not defined for $(typeof(a))")
 

src/builtins.c

@@ -1741,7 +1741,7 @@ JL_CALLABLE(jl_f_set_binding_type)
 
 JL_CALLABLE(jl_f_arrayfreeze)
 {
-    JL_NARGSV(arrayfreeze, 1);
+    JL_NARGS(arrayfreeze, 1, 1);
     JL_TYPECHK(arrayfreeze, array, args[0]);
     jl_array_t *a = (jl_array_t*)args[0];
     jl_datatype_t *it = (jl_datatype_t *)jl_apply_type2((jl_value_t*)jl_immutable_array_type,
@@ -1760,7 +1760,7 @@ JL_CALLABLE(jl_f_mutating_arrayfreeze)
     // N.B.: These error checks pretend to be arrayfreeze since this is a drop
     // in replacement and we don't want to change the visible error type in the
     // optimizer
-    JL_NARGSV(arrayfreeze, 1);
+    JL_NARGS(arrayfreeze, 1, 1);
     JL_TYPECHK(arrayfreeze, array, args[0]);
     jl_array_t *a = (jl_array_t*)args[0];
     jl_datatype_t *it = (jl_datatype_t *)jl_apply_type2((jl_value_t*)jl_immutable_array_type,
@@ -1771,7 +1771,7 @@ JL_CALLABLE(jl_f_mutating_arrayfreeze)
 
 JL_CALLABLE(jl_f_arraythaw)
 {
-    JL_NARGSV(arraythaw, 1);
+    JL_NARGS(arraythaw, 1, 1);
     if (((jl_datatype_t*)jl_typeof(args[0]))->name != jl_immutable_array_typename) {
         jl_type_error("arraythaw", (jl_value_t*)jl_immutable_array_type, args[0]);
     }