Trying to allow Int8 as indices

ext/OffsetArraysAdaptExt.jl

@@ -10,7 +10,7 @@ Adapt.adapt_structure(to, O::OffsetArray) = OffsetArrays.parent_call(x -> Adapt.
 
 @static if isdefined(Adapt, :parent_type)
     # To support Adapt 3.0 which doesn't have parent_type defined
-    Adapt.parent_type(::Type{OffsetArray{T,N,AA}}) where {T,N,AA} = AA
+    Adapt.parent_type(::Type{OffsetArray{T,N,AA,I}}) where {T,N,AA,I} = AA
     Adapt.unwrap_type(W::Type{<:OffsetArray}) = unwrap_type(parent_type(W))
 end
 

src/OffsetArrays.jl

@@ -109,32 +109,51 @@ julia> OffsetArray(a, OffsetArrays.Origin(0)) # set the origin to zero along eac
 
 
 """
-struct OffsetArray{T,N,AA<:AbstractArray{T,N}} <: AbstractArray{T,N}
+struct OffsetArray{T, N, AA<:AbstractArray{T,N}, I<:Integer} <: AbstractArray{T, N}
     parent::AA
-    offsets::NTuple{N,Int}
-    @inline function OffsetArray{T, N, AA}(parent::AA, offsets::NTuple{N, Int}; checkoverflow = true) where {T, N, AA<:AbstractArray{T,N}}
+    offsets::NTuple{N,I}
+    # Inner constructor with all 4 type parameters bound
+    @inline function OffsetArray{T, N, AA, I}(parent::AA, offsets::NTuple{N, I}; checkoverflow=true) where {T, N, AA<:AbstractArray{T,N}, I<:Integer}
         # allocation of `map` on tuple is optimized away
         checkoverflow && map(overflow_check, axes(parent), offsets)
-        new{T, N, AA}(parent, offsets)
+        new{T, N, AA, I}(parent, offsets)
     end
+    # Special case of a 0-dimensional array, offsets do not make sense here
+    @inline function OffsetArray{T, N, AA, I}(parent::AA, offsets::Tuple{}; checkoverflow=true) where {T, N, AA<:AbstractArray{T,0}, I<:Integer}
+        new{T, N, AA, I}(parent, offsets)
+    end
+end
+
+# Helper to get the element type of an offset tuple
+_offset_eltype(::Tuple{I, Vararg{I}}) where {I<:Integer} = I
+_offset_eltype(::Tuple{}) = Int
+
+# Outer constructor that infers I from the offsets - for backwards compatibility with 3-param calls
+@inline function OffsetArray{T, N, AA}(parent::AA, offsets::NTuple{N, <:Integer}; checkoverflow=true) where {T, N, AA<:AbstractArray{T,N}}
+    I = _offset_eltype(offsets)
+    OffsetArray{T, N, AA, I}(parent, offsets; checkoverflow=checkoverflow)
+end
+# Special case for 0-dimensional arrays with 3-param call
+@inline function OffsetArray{T, N, AA}(parent::AA, offsets::Tuple{}; checkoverflow=true) where {T, N, AA<:AbstractArray{T,0}}
+    OffsetArray{T, N, AA, _offset_eltype(offsets)}(parent, offsets; checkoverflow=checkoverflow)
 end
 
 """
     OffsetVector(v, index)
 
 Type alias and convenience constructor for one-dimensional [`OffsetArray`](@ref)s.
 """
-const OffsetVector{T,AA<:AbstractVector{T}} = OffsetArray{T,1,AA}
+const OffsetVector{T,AA<:AbstractVector{T},I<:Integer} = OffsetArray{T,1,AA,I}
 
 """
     OffsetMatrix(A, index1, index2)
 
 Type alias and convenience constructor for two-dimensional [`OffsetArray`](@ref)s.
 """
-const OffsetMatrix{T,AA<:AbstractMatrix{T}} = OffsetArray{T,2,AA}
+const OffsetMatrix{T,AA<:AbstractMatrix{T},I<:Integer} = OffsetArray{T,2,AA,I}
 
 # checks if the offset may be added to the range without overflowing
-function overflow_check(r::AbstractUnitRange, offset::Integer)
+function overflow_check(r::AbstractUnitRange, offset::Integer) 
     Base.hastypemax(eltype(r)) || return nothing
     # This gives some performance boost https://github.com/JuliaLang/julia/issues/33273
     throw_upper_overflow_error(val) = throw(OverflowError("offset should be <= $(typemax(Int) - val) corresponding to the axis $r, received an offset $offset"))
@@ -176,16 +195,13 @@ end
 for FT in (:OffsetArray, :OffsetVector, :OffsetMatrix)
     # Nested OffsetArrays may strip off the wrapper and collate the offsets
     # empty tuples are handled here
-    @eval @inline function $FT(A::OffsetArray, offsets::Tuple{Vararg{Int}}; checkoverflow = true)
+    @eval @inline function $FT(A::OffsetArray, offsets::Tuple{Vararg{Integer}}; checkoverflow = true)
         _checkindices(A, offsets, "offsets")
         # ensure that the offsets may be added together without an overflow
         checkoverflow && map(overflow_check, axes(A), offsets)
         I = map(+, _offsets(A, parent(A)), offsets)
         $FT(parent(A), I, checkoverflow = false)
     end
-    @eval @inline function $FT(A::OffsetArray, offsets::Tuple{Integer,Vararg{Integer}}; kw...)
-        $FT(A, map(Int, offsets); kw...)
-    end
 
     # In general, indices get converted to AbstractUnitRanges.
     # CartesianIndices{N} get converted to N ranges
@@ -224,16 +240,13 @@ end
 @inline OffsetArray{T,N}(M::AbstractArray{T,N}, I...; kw...) where {T,N} = OffsetArray{T,N,typeof(M)}(M, I...; kw...)
 
 @inline OffsetArray{T,N,A}(M::AbstractArray{<:Any,N}, I...; kw...) where {T,N,A<:AbstractArray{T,N}} = OffsetArray{T,N,A}(M, I; kw...)
-@inline function OffsetArray{T,N,A}(M::AbstractArray{<:Any,N}, I::NTuple{N,Int}; checkoverflow = true) where {T,N,A<:AbstractArray{T,N}}
+@inline function OffsetArray{T,N,A}(M::AbstractArray{<:Any,N}, I::NTuple{N,Integer}; checkoverflow = true) where {T,N,A<:AbstractArray{T,N}}
     checkoverflow && map(overflow_check, axes(M), I)
     Mv = no_offset_view(M)
     MvA = convert(A, Mv)::A
     Iof = map(+, _offsets(M), I)
     OffsetArray{T,N,A}(MvA, Iof, checkoverflow = false)
 end
-@inline function OffsetArray{T, N, AA}(parent::AbstractArray{<:Any,N}, offsets::NTuple{N, Integer}; kw...) where {T, N, AA<:AbstractArray{T,N}}
-    OffsetArray{T, N, AA}(parent, map(Int, offsets)::NTuple{N,Int}; kw...)
-end
 @inline function OffsetArray{T,N,A}(M::AbstractArray{<:Any,N}, I::Tuple{AbstractUnitRange,Vararg{AbstractUnitRange}}; kw...) where {T,N,A<:AbstractArray{T,N}}
     _checkindices(M, I, "indices")
     # Performance gain by wrapping the error in a function: see https://github.com/JuliaLang/julia/issues/37558
@@ -275,7 +288,7 @@ end
 @inline OffsetArray{T}(init::ArrayInitializer, inds...; kw...) where {T} = OffsetArray{T}(init, inds; kw...)
 
 Base.IndexStyle(::Type{OA}) where {OA<:OffsetArray} = IndexStyle(parenttype(OA))
-parenttype(::Type{OffsetArray{T,N,AA}}) where {T,N,AA} = AA
+parenttype(::Type{OffsetArray{T,N,AA,I}}) where {T,N,AA,I} = AA
 parenttype(A::OffsetArray) = parenttype(typeof(A))
 
 Base.parent(A::OffsetArray) = A.parent
@@ -333,6 +346,7 @@ function Base.similar(::Type{T}, shape::Tuple{OffsetAxisKnownLength,Vararg{Offse
     P = _similar_axes_or_length(T, new_shape, shape)
     OffsetArray(P, map(_offset, axes(P), shape))
 end
+
 # Try to use the axes to generate the parent array type
 # This is useful if the axes have special meanings, such as with static arrays
 # This method is hit if at least one axis provided to similar(A, T, axes) is an IdOffsetRange
@@ -381,6 +395,7 @@ Base.reshape(A::OffsetArray, inds::Dims) = _reshape_nov(A, inds)
 if VERSION < v"1.10.7"
     # the specialized reshape(parent::AbstractVector, ::Tuple{Colon}) is available in Base at least on this version
     Base.reshape(A::OffsetVector, ::Tuple{Colon}) = A
+    # Keep Int here (not Integer) to avoid method ambiguity with Base on older Julia versions
     Base.reshape(A::OffsetArray, inds::Tuple{Vararg{Union{Int,Colon}}}) = _reshape_nov(A, inds)
 end
 
@@ -430,13 +445,13 @@ end
 # but that case is handled by getindex(::OffsetArray{<:Any,N}, ::Vararg{Colon,N})
 @propagate_inbounds Base.getindex(A::OffsetArray, c::Colon) = A.parent[:]
 
-@inline function Base.getindex(A::OffsetVector, i::Int)
+@inline function Base.getindex(A::OffsetVector{T,AA,<:Integer}, i::Int) where {T,AA<:AbstractVector{T}}
     @boundscheck checkbounds(A, i)
     @inbounds parent(A)[parentindex(Base.axes1(A), i)]
 end
 @propagate_inbounds Base.getindex(A::OffsetArray, i::Int)  = parent(A)[i]
 
-@inline function Base.setindex!(A::OffsetArray{T,N}, val, I::Vararg{Int,N}) where {T,N}
+@inline function Base.setindex!(A::OffsetArray{T,N,AA,<:Any}, val, I::Vararg{Int,N}) where {T,N,AA}
     @boundscheck checkbounds(A, I...)
     J = map(parentindex, axes(A), I)
     @inbounds parent(A)[J...] = val
@@ -459,7 +474,7 @@ Base.in(x, A::OffsetArray) = in(x, parent(A))
 Base.copy(A::OffsetArray) = parent_call(copy, A)
 
 Base.strides(A::OffsetArray) = strides(parent(A))
-Base.elsize(::Type{OffsetArray{T,N,A}}) where {T,N,A} = Base.elsize(A)
+Base.elsize(::Type{OffsetArray{T,N,A,I}}) where {T,N,A,I} = Base.elsize(A)
 Base.cconvert(P::Type{Ptr{T}}, A::OffsetArray{T}) where {T} = Base.cconvert(P, parent(A))
 if VERSION < v"1.11-"
     @inline Base.unsafe_convert(::Type{Ptr{T}}, A::OffsetArray{T}) where {T} = Base.unsafe_convert(Ptr{T}, parent(A))
@@ -491,7 +506,7 @@ end
 end
 
 # An OffsetUnitRange might use the rapid getindex(::Array, ::AbstractUnitRange{Int}) for contiguous indexing
-@propagate_inbounds function Base.getindex(A::Array, r::OffsetUnitRange{Int})
+@propagate_inbounds function Base.getindex(A::Array, r::OffsetUnitRange{Integer})
     B = A[_contiguousindexingtype(parent(r))]
     OffsetArray(B, axes(r), checkoverflow = false)
 end
@@ -530,7 +545,7 @@ end
 # An OffsetUnitRange{Int} has an equivalent IdOffsetRange with the same values and axes,
 # something similar also holds for OffsetUnitRange{BigInt}
 # We may replace the former with the latter in an indexing operation to obtain a performance boost
-@inline function Base.to_index(r::OffsetUnitRange{<:Union{Int,BigInt}})
+@inline function Base.to_index(r::OffsetUnitRange{<:Integer})
     of = first(axes(r,1)) - 1
     IdOffsetRange(_subtractoffset(parent(r), of), of)
 end

src/axes.jl

@@ -104,20 +104,20 @@ end
 _bool_check(::Type, r, offset) = nothing
 
 # Construction/coercion from arbitrary AbstractUnitRanges
-function IdOffsetRange{T,I}(r::AbstractUnitRange, offset::Integer = 0) where {T<:Integer,I<:AbstractUnitRange{T}}
+function IdOffsetRange{T,I}(r::AbstractUnitRange, offset::Integer=Int8(0)) where {T<:Integer,I<:AbstractUnitRange{T}}
     rc, o = offset_coerce(I, r)
     return IdOffsetRange{T,I}(rc, convert(T, o+offset)::T)
 end
-function IdOffsetRange{T}(r::AbstractUnitRange, offset::Integer = 0) where T<:Integer
+function IdOffsetRange{T}(r::AbstractUnitRange, offset::Integer=Int8(0)) where T<:Integer
     rc = convert(AbstractUnitRange{T}, r)::AbstractUnitRange{T}
     return IdOffsetRange{T,typeof(rc)}(rc, convert(T, offset)::T)
 end
-IdOffsetRange(r::AbstractUnitRange{T}, offset::Integer = 0) where T<:Integer =
+IdOffsetRange(r::AbstractUnitRange{T}, offset::Integer=Int8(0)) where T<:Integer =
     IdOffsetRange{T,typeof(r)}(r, convert(T, offset)::T)
 
 # Coercion from other IdOffsetRanges
 IdOffsetRange{T,I}(r::IdOffsetRange{T,I}) where {T<:Integer,I<:AbstractUnitRange{T}} = r
-function IdOffsetRange{T,I}(r::IdOffsetRange, offset::Integer = 0) where {T<:Integer,I<:AbstractUnitRange{T}}
+function IdOffsetRange{T,I}(r::IdOffsetRange, offset::Integer=Int8(0)) where {T<:Integer,I<:AbstractUnitRange{T}}
     rc, offset_rc = offset_coerce(I, r.parent)
     return IdOffsetRange{T,I}(rc, convert(T, r.offset + offset + offset_rc)::T)
 end
@@ -134,7 +134,7 @@ _subtractindexoffset(values, indices, offset) = _subtractoffset(values, offset)
 function IdOffsetRange(; values::AbstractUnitRange{<:Integer}, indices::AbstractUnitRange{<:Integer})
     length(values) == length(indices) || throw(ArgumentError("values and indices must have the same length"))
     values_nooffset = no_offset_view(values)
-    offset = first(indices) - 1
+    offset = first(indices) - Int8(1)
     values_minus_offset = _subtractindexoffset(values_nooffset, indices, offset)
     return IdOffsetRange(values_minus_offset, offset)
 end

src/utils.jl

@@ -3,7 +3,7 @@
 _indexoffset(r::AbstractRange) = first(r) - 1
 _indexoffset(i::Integer) = 0
 _indexlength(r::AbstractRange) = length(r)
-_indexlength(i::Integer) = Int(i)
+_indexlength(i::Integer) = Int(i)  # Convert to Int for Base compatibility (reshape, etc.)
 _indexlength(i::Colon) = Colon()
 
 # utility methods used in reshape
@@ -17,7 +17,10 @@ _toaxis(i) = i
 _strip_IdOffsetRange(r::IdOffsetRange) = parent(r)
 _strip_IdOffsetRange(r) = r
 
-_offset(axparent::AbstractUnitRange, ax::AbstractUnitRange) = first(ax) - first(axparent)
+_offset(axparent::AbstractUnitRange, ax::AbstractUnitRange{Int}) = first(ax) - first(axparent)
+
+# Keep the provided integer if possible
+_offset(axparent::AbstractUnitRange, ax::AbstractUnitRange{I}) where {I<:Integer} = first(ax) - convert(I, first(axparent))
 _offset(axparent::AbstractUnitRange, ::Union{Integer, Colon}) = 1 - first(axparent)
 
 _offsets(A::AbstractArray) = map(ax -> first(ax) - 1, axes(A))