fix tests and constructors

Author: simone-silvestri

ext/OffsetArraysAdaptExt.jl

@@ -10,6 +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,I}}) where {T,N,AA,I} = AA
     Adapt.parent_type(::Type{OffsetArray{T,N,AA}}) where {T,N,AA} = AA
     Adapt.unwrap_type(W::Type{<:OffsetArray}) = unwrap_type(parent_type(W))
 end

src/OffsetArrays.jl

@@ -112,17 +112,32 @@ julia> OffsetArray(a, OffsetArrays.Origin(0)) # set the origin to zero along eac
 struct OffsetArray{T, N, AA<:AbstractArray{T,N}, I<:Integer} <: AbstractArray{T, N}
     parent::AA
     offsets::NTuple{N,I}
-    @inline function OffsetArray{T, N, AA}(parent::AA, offsets::NTuple{N, I}; checkoverflow=true) where {T, N, AA<:AbstractArray{T,N}, I<:Integer}
+    # 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, I}(parent, offsets)
     end
-    #special case of a 0-dimensional array, offsets do not make sense here
-    @inline function OffsetArray{T, N, AA}(parent::AA, offsets::Tuple{}; checkoverflow=true) where {T, N, AA<:AbstractArray{T,0}}
-        new{T, N, AA, Int}(parent, offsets)
+    # 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, Int}(parent, offsets; checkoverflow=checkoverflow)
+end
+
 """
     OffsetVector(v, index)
 

test/runtests.jl

@@ -459,9 +459,10 @@ Base.Int(a::WeirdInteger) = a
         ]
 
         offsets = size.(one_based_axes[1], 1)
-        offsets_big = map(big, offsets)
+        # Test with different integer offset types (Int8, Int16, Int32, Int64, Int128, BigInt)
+        offsets_all = [map(T, offsets) for T in (Int8, Int16, Int32, Int64, Int128, BigInt)]
 
-        for inds in Any[offsets, offsets_big, one_based_axes...]
+        for inds in Any[offsets_all..., one_based_axes...]
             # test indices API
             a = OffsetVector{Float64}(undef, inds)
             @test eltype(a) === Float64
@@ -489,7 +490,7 @@ Base.Int(a::WeirdInteger) = a
         end
 
         # nested OffsetVectors
-        for inds in Any[offsets, offsets_big]
+        for inds in offsets_all
             a = OffsetVector{Float64}(undef, inds)
             b = OffsetVector(a, inds); b2 = OffsetVector(a, inds...);
             @test eltype(b) === eltype(b2) === Float64
@@ -653,9 +654,10 @@ Base.Int(a::WeirdInteger) = a
         ]
 
         offsets = size.(one_based_axes[1], 1)
-        offsets_big = map(big, offsets)
+        # Test with different integer offset types (Int8, Int16, Int32, Int64, Int128, BigInt)
+        offsets_all = [map(T, offsets) for T in (Int8, Int16, Int32, Int64, Int128, BigInt)]
 
-        for inds in Any[offsets, offsets_big, one_based_axes...]
+        for inds in Any[offsets_all..., one_based_axes...]
             # test API
             a = OffsetMatrix{Float64}(undef, inds)
             ax = (IdOffsetRange(Base.OneTo(4), 0), IdOffsetRange(Base.OneTo(3), 0))
@@ -682,7 +684,7 @@ Base.Int(a::WeirdInteger) = a
         @test_throws Union{ArgumentError, ErrorException} OffsetMatrix{Float64}(undef, 2, -2) # only positive numbers works
 
         # nested OffsetMatrices
-        for inds in Any[offsets, offsets_big]
+        for inds in offsets_all
             a = OffsetMatrix{Float64}(undef, inds)
             b = OffsetMatrix(a, inds); b2 = OffsetMatrix(a, inds...);
             @test eltype(b) === eltype(b2) === Float64
@@ -857,9 +859,9 @@ Base.Int(a::WeirdInteger) = a
         # ndim of an OffsetArray should match that of the parent
         @test_throws TypeError OffsetArray{Float64,3,Matrix{Float64}}
 
-        # should throw a TypeError if the offsets can not be converted to Ints
-        # this test does not work anymore?
-        @test_throws TypeError OffsetVector{Int,Vector{Int}}(zeros(Int,2), (WeirdInteger(1),))
+        # should throw an error if the offset type doesn't support proper arithmetic operations
+        # (previously threw TypeError when converting to Int, now throws during overflow_check)
+        @test_throws Exception OffsetVector{Int,Vector{Int}}(zeros(Int,2), (WeirdInteger(1),))
     end
 
     @testset "custom range types" begin