Fix type instability for vec[1, end] indexing

Fixes #525

The issue was that when `end` is used for the last dimension, `lastindex(VA, d)`
returns `RaggedEnd(0, lastindex(VA.u))` as a sentinel for an already-resolved index.
However, the `getindex` dispatch path couldn't infer the return type because
`cols.dim == 0` is a runtime check.

This PR adds:
1. A specialized `getindex(A, i::Int, re::RaggedEnd)` method that handles the
   common case `vec[i, end]` directly with type stability
2. A helper function `_ragged_getindex_int_col` as a function barrier for the
   Int column case
3. An early check in `_ragged_getindex` for the `RaggedEnd` sentinel case

The fix ensures that `@code_warntype` shows the proper return type (Float64)
instead of Any.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: claude

src/vector_of_array.jl

@@ -564,6 +564,22 @@ function Base.:(:)(start::Integer, step::Integer, stop::RaggedEnd)
 end
 Base.broadcastable(x::RaggedRange) = Ref(x)
 
+# Specialized method for type stability when last index is RaggedEnd with dim=0 (resolved column index)
+# This handles the common case: vec[i, end] where end -> RaggedEnd(0, lastindex)
+Base.@propagate_inbounds function Base.getindex(
+        A::AbstractVectorOfArray, i::Int, re::RaggedEnd
+    )
+    if re.dim == 0
+        # Sentinel case: RaggedEnd(0, offset) means offset is the resolved column index
+        return A.u[re.offset][i]
+    else
+        # Non-sentinel case: resolve the ragged index for the last column
+        col = lastindex(A.u)
+        resolved_idx = lastindex(A.u[col], re.dim) + re.offset
+        return A.u[col][i, resolved_idx]
+    end
+end
+
 @inline function _is_ragged_dim(VA::AbstractVectorOfArray, d::Integer)
     length(VA.u) <= 1 && return false
     first_size = size(VA.u[1], d)
@@ -767,6 +783,18 @@ end
     return args
 end
 
+# Helper function for type-stable getindex when column index is an Int
+# This function barrier ensures the compiler can fully infer the return type
+@inline function _ragged_getindex_int_col(A::AbstractVectorOfArray, prefix, cols::Int)
+    if all(idx -> idx === Colon(), prefix)
+        return A.u[cols]
+    end
+    resolved = _resolve_ragged_indices(prefix, A, cols)
+    inner_nd = ndims(A.u[cols])
+    padded = (resolved..., ntuple(_ -> Colon(), max(inner_nd - length(resolved), 0))...)
+    return A.u[cols][padded...]
+end
+
 @inline function _ragged_getindex(A::AbstractVectorOfArray, I...)
     n = ndims(A)
     # Special-case when user provided one fewer index than ndims(A): last index is column selector.
@@ -842,14 +870,12 @@ end
         cols = Colon()
         prefix = I
     end
+    # Handle RaggedEnd sentinel (dim=0) early for type stability - this represents an already-resolved Int
+    if cols isa RaggedEnd && cols.dim == 0
+        return _ragged_getindex_int_col(A, prefix, cols.offset)
+    end
     if cols isa Int
-        if all(idx -> idx === Colon(), prefix)
-            return A.u[cols]
-        end
-        resolved = _resolve_ragged_indices(prefix, A, cols)
-        inner_nd = ndims(A.u[cols])
-        padded = (resolved..., ntuple(_ -> Colon(), max(inner_nd - length(resolved), 0))...)
-        return A.u[cols][padded...]
+        return _ragged_getindex_int_col(A, prefix, cols)
     else
         col_idxs = _column_indices(A, cols)
         # Resolve sentinel RaggedEnd/RaggedRange (dim==0) for column selection

test/interface_tests.jl

@@ -66,6 +66,12 @@ push!(testda, [-1, -2, -3, -4])
 @inferred sum(testva)
 @inferred sum(VectorOfArray([VectorOfArray([zeros(4, 4)])]))
 @inferred mapreduce(string, *, testva)
+# Type stability for `end` indexing (issue #525)
+testva_end = VectorOfArray([fill(2.0, 2) for i in 1:10])
+# Use lastindex directly since `end` doesn't work in SafeTestsets
+last_col = lastindex(testva_end, 2)
+@inferred testva_end[1, last_col]
+@test testva_end[1, last_col] == 2.0
 
 # mapreduce
 testva = VectorOfArray([[1, 2, 3], [4, 5, 6], [7, 8, 9]])