Merge branch 'master' into master

Author: simone-silvestri

.github/workflows/UnitTest.yml

@@ -1,9 +1,9 @@
 name: Unit test
 
 on:
-  create:
-    tags:
   push:
+    tags:
+      - 'v*'
     branches:
       - master
     paths-ignore:
@@ -40,27 +40,14 @@ jobs:
             julia-arch: x86
 
     steps:
-      - uses: actions/checkout@v4
-      - name: "Set up Julia"
-        uses: julia-actions/[email protected]
+      - uses: actions/checkout@v6
+      - uses: julia-actions/setup-julia@v2
         with:
           version: ${{ matrix.julia-version }}
           arch: ${{ matrix.julia-arch }}
-
-      - name: Cache artifacts
-        uses: actions/cache@v4
-        env:
-          cache-name: cache-artifacts
-        with:
-          path: ~/.julia/artifacts
-          key: ${{ runner.os }}-test-${{ env.cache-name }}-${{ hashFiles('**/Project.toml') }}
-          restore-keys: |
-            ${{ runner.os }}-test-${{ env.cache-name }}-
-            ${{ runner.os }}-test-
-            ${{ runner.os }}-
+      - uses: julia-actions/cache@v2
       - name: "Unit Test"
         uses: julia-actions/julia-runtest@v1
-
       - uses: julia-actions/julia-processcoverage@v1
       - uses: codecov/codecov-action@v5
         with:

.github/workflows/docs.yml

@@ -18,12 +18,12 @@ jobs:
         julia-version: [1]
         os: [ubuntu-latest]
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
       - uses: julia-actions/setup-julia@latest
         with:
           version: ${{ matrix.julia-version }}
       - name: Cache artifacts
-        uses: actions/cache@v4
+        uses: actions/cache@v5
         env:
           cache-name: cache-artifacts
         with:

.github/workflows/invalidations.yml

@@ -8,12 +8,12 @@ jobs:
     - uses: julia-actions/setup-julia@v2
       with:
         version: '1.10'
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
     - uses: julia-actions/julia-buildpkg@latest
     - uses: julia-actions/julia-invalidations@v1
       id: invs_pr
 
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
       with:
         ref: 'master'
     - uses: julia-actions/julia-buildpkg@latest

Project.toml

@@ -1,6 +1,6 @@
 name = "OffsetArrays"
 uuid = "6fe1bfb0-de20-5000-8ca7-80f57d26f881"
-version = "1.16.0"
+version = "1.17.0"
 
 [deps]
 Adapt = "79e6a3ab-5dfb-504d-930d-738a2a938a0e"

ext/OffsetArraysAdaptExt.jl

@@ -11,6 +11,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.unwrap_type(W::Type{<:OffsetArray}) = unwrap_type(parent_type(W))
 end
 
 end

src/OffsetArrays.jl

@@ -694,19 +694,60 @@ julia> A
 no_offset_view(A::OffsetArray) = no_offset_view(parent(A))
 if isdefined(Base, :IdentityUnitRange)
     # valid only if Slice is distinguished from IdentityUnitRange
-    no_offset_view(a::Base.Slice{<:Base.OneTo}) = a
-    no_offset_view(a::Base.Slice) = Base.Slice(UnitRange(a))
-    no_offset_view(S::SubArray) = view(parent(S), map(no_offset_view, parentindices(S))...)
+    _onebasedslice(S::Base.Slice) = Base.Slice(Base.OneTo(length(S)))
+    _onebasedslice(S::Base.Slice{<:Base.OneTo}) = S
+    _onebasedslice(S) = S
+    _isoffsetslice(::Any) = false
+    _isoffsetslice(::Base.Slice) = true
+    _isoffsetslice(::Base.Slice{<:Base.OneTo}) = false
+    function no_offset_view(S::SubArray)
+        #= If a view contains an offset Slice axis,
+        i.e. it is a view of an offset array along the offset axis,
+        we shift the axis to a 1-based one.
+        E.g. Slice(2:3) -> Slice(Base.OneTo(2))
+        We transform the `parent` as well as the `parentindices`,
+        so that the view still points to the same elements, even though the indices have changed.
+        This way, we retain the axis of the view as a `Slice`
+        =#
+        P = parent(S)
+        pinds = parentindices(S)
+        #=
+        Check if all the axes are `Slice`s and the parent has `OneTo` axes,
+        in which case we may unwrap the `OffsetArray` and forward the view to the parent.
+        =#
+        may_pop_parent = all(_isoffsetslice, pinds) && P isa OffsetArray && all(x -> x isa Base.OneTo, axes(parent(P)))
+        if may_pop_parent
+            return no_offset_view(P)
+        end
+        #=
+        we convert offset `Slice`s to 1-based ones using `_onebasedslice`.
+        The next call, `no_offset_view`, is a no-op on a `Slice{<:OneTo}`,
+        while it converts the offset axes to 1-based ones.
+        Eventually, we end up with a `Tuple` comprising `Slice{<:OneTo}`s and other 1-based axes.
+
+        The difference between `_onebasedslice` and `no_offset_view` is that
+        the latter does not change the value of the range, while the former does.
+        =#
+        newviewinds = map(no_offset_view ∘ _onebasedslice, pinds)
+        needs_shifting = any(_isoffsetslice, pinds)
+        P_maybeshiftedinds = if needs_shifting
+            t = Origin(parent(S)).index
+            neworigin = ntuple(i -> _isoffsetslice(pinds[i]) ? 1 : t[i], length(t))
+            Origin(neworigin)(P)
+        else
+            P
+        end
+        view(P_maybeshiftedinds, newviewinds...)
+    end
 end
 no_offset_view(a::Array) = a
 no_offset_view(i::Number) = i
 no_offset_view(A::AbstractArray) = _no_offset_view(axes(A), A)
 _no_offset_view(::Tuple{}, A::AbstractArray{T,0}) where T = A
 _no_offset_view(::Tuple{Base.OneTo, Vararg{Base.OneTo}}, A::AbstractArray) = A
-# the following method is needed for ambiguity resolution
-_no_offset_view(::Tuple{Base.OneTo, Vararg{Base.OneTo}}, A::AbstractUnitRange) = A
-_no_offset_view(::Any, A::AbstractArray) = OffsetArray(A, Origin(1))
-_no_offset_view(::Any, A::AbstractUnitRange) = UnitRange(A)
+_no_offset_view(::Any, A::AbstractArray) = _no_offset_view(A)
+_no_offset_view(A::AbstractArray) = OffsetArray(A, Origin(1))
+_no_offset_view(A::AbstractUnitRange) = UnitRange(A)
 
 #####
 # center/centered

test/runtests.jl

@@ -2412,6 +2412,12 @@ Base.getindex(x::PointlessWrapper, i...) = x.parent[i...]
     @test OffsetArrays.no_offset_view(V) == collect(V)
     V = @view O[:,:]
     @test IndexStyle(A) == IndexStyle(O) == IndexStyle(V) == IndexStyle(OffsetArrays.no_offset_view(V)) == IndexLinear()
+
+    @testset "issue #375" begin
+        arr = OffsetArray(reshape(1:15, 3, 5), 2, 3)
+        arr_no_offset = OffsetArrays.no_offset_view(@view arr[:, 4])
+        @test all(!Base.has_offset_axes, axes(arr_no_offset))
+    end
 end
 
 @testset "no nesting" begin
@@ -2546,8 +2552,12 @@ end
     @test parent(s_arr) isa SArray
     @test arr == adapt(Array, s_arr)
 
+    arr2 = OffsetArray(view(rand(5, 5), 2:4, 2:4), -1:1, -1:1)
+
     if isdefined(Adapt, :parent_type)
         @test Adapt.parent_type(typeof(arr)) == typeof(arr.parent)
+        @test Adapt.unwrap_type(typeof(arr)) == typeof(arr.parent)
+        @test Adapt.unwrap_type(typeof(arr2)) == typeof(arr.parent)
     end
 end