fix #17372, only accept Int in reshape

[JeffBezanson]

I believe this is a bug, since it's very strange that passing an Int32 resulted in a ReshapedArray while passing an Int resulted in an Array.

This synchronizes DimOrInd with other index-related types, all of which use Int. This will also affect packages like DistributedArrays, which also assume Int.

[tkelman]

sure we don't have any tests that use this? this is one possible decision to make on that issue but I wouldn't consider turning it into an error a "fix"

[JeffBezanson]

It was always an error before. And I certainly hope we're not testing that passing a non-Int to reshape results in a ReshapedArray instead of an Array.

[tkelman]

the issue (and at least one duplicate of it) is saying "it would be nice if this weren't an error." I agree the inconsistency here is good to fix, but a looser signature would be more convenient

[JeffBezanson]

For that we would have to change a large number of places, plus many packages.

[timholy]

Maybe make it AbstractUnitRange{Int}?

[timholy]

I like this solution. There are a lot of inconsistencies though. Here are some other examples where we specify the desired size of something using Integer:

julia/base/sysimg.jl

Lines 75 to 85 in f331e02

	(::Type{Array{T}}){T}(m::Integer) = Array{T,1}(Int(m))
	(::Type{Array{T}}){T}(m::Integer, n::Integer) = Array{T,2}(Int(m), Int(n))
	(::Type{Array{T}}){T}(m::Integer, n::Integer, o::Integer) = Array{T,3}(Int(m), Int(n), Int(o))
	(::Type{Array{T}}){T}(d::Integer...) = Array{T}(convert(Tuple{Vararg{Int}}, d))
	(::Type{Vector})() = Array{Any,1}(0)
	(::Type{Vector{T}}){T}(m::Integer) = Array{T,1}(Int(m))
	(::Type{Vector})(m::Integer) = Array{Any,1}(Int(m))
	(::Type{Matrix})() = Array{Any,2}(0, 0)
	(::Type{Matrix{T}}){T}(m::Integer, n::Integer) = Matrix{T}(Int(m), Int(n))
	(::Type{Matrix})(m::Integer, n::Integer) = Matrix{Any}(Int(m), Int(n))

julia/base/abstractarray.jl

Line 341 in f331e02

similar{T}(a::AbstractArray{T}, dims::DimOrInd...) = similar(a, T, to_shape(dims))

julia/base/bitarray.jl

Line 29 in f331e02

BitArray(dims::Integer...) = BitArray(map(Int,dims))

julia/base/mmap.jl

Line 166 in f331e02

mmap{T<:Array}(::Type{T}, i::Integer...; shared::Bool=true) = mmap(Anonymous(), T, convert(Tuple{Vararg{Int}},i), Int64(0); shared=shared)

julia/base/random.jl

Line 230 in f331e02

rand(dims::Integer...) = rand(convert(Tuple{Vararg{Int}}, dims))

julia/base/sharedarray.jl

Lines 33 to 40 in f331e02

	(::Type{SharedArray{T}}){T}(d::Integer...; kwargs...) =
	SharedArray(T, d; kwargs...)
	(::Type{SharedArray{T}}){T}(m::Integer; kwargs...) =
	SharedArray(T, m; kwargs...)
	(::Type{SharedArray{T}}){T}(m::Integer, n::Integer; kwargs...) =
	SharedArray(T, m, n; kwargs...)
	(::Type{SharedArray{T}}){T}(m::Integer, n::Integer, o::Integer; kwargs...) =
	SharedArray(T, m, n, o; kwargs...)

It would be great to come up with some kind of consistent policy for 0.6.

[JeffBezanson]

Fair enough; I will drop fixes #17372 from this, and we will have to explore a more comprehensive change from Int to Integer in 0.6. Will just fix the inconsistency for now.

[timholy]

Or we can go from Integer to Int; I don't really care which we choose. I think the marginal benefit of allowing Integer is pretty small.

[timholy]

Hmm, though maybe 32bit systems mmapping files > 2GB is an argument to allow Integer.

[tkelman]

x-ref #16582 as well