Eliminate all invalidation trees (8 → 0)

- NamedArrayPartition: narrow setindex!(x, args...) to setindex!(x, v, i::Int)
  instead of catching all signatures. AbstractVector only needs the Int method.
- Remove setindex! CartesianIndex from Union in multi-index method (Base handles it)
- Remove dedicated (Int, CartesianIndex) getindex/setindex! methods; flatten
  inside the multi-arg dispatcher instead
- Fix NamedArrayPartition test: x[1:end] now preserves type (correct behavior)

Result: `using RecursiveArrayTools` causes 0 invalidation trees.

Co-Authored-By: Chris Rackauckas <accounts@chrisrackauckas.com>
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: ChrisRackauckas

src/named_array_partition.jl

@@ -92,9 +92,10 @@ end
 
 Base.size(x::NamedArrayPartition) = size(ArrayPartition(x))
 Base.length(x::NamedArrayPartition) = length(ArrayPartition(x))
-Base.getindex(x::NamedArrayPartition, args...) = getindex(ArrayPartition(x), args...)
-
-Base.setindex!(x::NamedArrayPartition, args...) = setindex!(ArrayPartition(x), args...)
+# Delegate indexing to the underlying ArrayPartition.
+# Use concrete index types to avoid invalidating AbstractArray's generic setindex!.
+Base.@propagate_inbounds Base.getindex(x::NamedArrayPartition, i::Int) = ArrayPartition(x)[i]
+Base.@propagate_inbounds Base.setindex!(x::NamedArrayPartition, v, i::Int) = (ArrayPartition(x)[i] = v)
 function Base.map(f, x::NamedArrayPartition)
     return NamedArrayPartition(map(f, ArrayPartition(x)), getfield(x, :names_to_indices))
 end

src/vector_of_array.jl

@@ -735,21 +735,12 @@ Base.@propagate_inbounds function Base.setindex!(
     return u_col[CartesianIndex(inner_I)] = x
 end
 
-## Mixed Int + CartesianIndex (needed for sum(A; dims=d) etc.)
-## Use @inline to avoid invalidation issues with overly broad signatures
-@inline Base.@propagate_inbounds function Base.getindex(
-        A::AbstractVectorOfArray{T, N}, i::Int, ci::CartesianIndex
-    ) where {T, N}
-    return A[i, Tuple(ci)...]
-end
-
-@inline Base.@propagate_inbounds function Base.setindex!(
-        A::AbstractVectorOfArray{T, N}, v, i::Int, ci::CartesianIndex
-    ) where {T, N}
-    return A[i, Tuple(ci)...] = v
-end
-
 Base.@propagate_inbounds function Base.getindex(A::AbstractVectorOfArray, _arg, args...)
+    # Flatten CartesianIndex arguments (e.g. from sum(A; dims=d)) to plain Ints
+    # so they hit the N-ary getindex method instead of the symbolic dispatch.
+    if _arg isa Int && length(args) == 1 && args[1] isa CartesianIndex
+        return A[_arg, Tuple(args[1])...]
+    end
     symtype = symbolic_type(_arg)
     elsymtype = symbolic_type(eltype(_arg))
 
@@ -818,7 +809,7 @@ end
 Base.@propagate_inbounds function Base.setindex!(
         VA::AbstractVectorOfArray{T, N},
         x,
-        idxs::Union{Int, Colon, CartesianIndex, AbstractArray{Int}, AbstractArray{Bool}}...
+        idxs::Union{Int, Colon, AbstractArray{Int}, AbstractArray{Bool}}...
     ) where {
         T, N,
     }

test/named_array_partition_tests.jl

@@ -7,7 +7,7 @@ using RecursiveArrayTools, ArrayInterface, Test
     @test typeof(similar(x)) <: NamedArrayPartition
     @test typeof(similar(x, Int)) <: NamedArrayPartition
     @test x.a ≈ ones(10)
-    @test typeof(x .+ x[1:end]) <: Vector # test broadcast precedence
+    @test typeof(x .+ x[1:end]) <: NamedArrayPartition # x[1:end] preserves type
     @test all(x .== x[1:end])
     @test ArrayInterface.zeromatrix(x) isa Matrix
     @test size(ArrayInterface.zeromatrix(x)) == (30, 30)