[RFC] Add index hint to BoundsError message

base/errorshow.jl

@@ -32,9 +32,25 @@ showerror(io::IO, ex) = show(io, ex)
 show_index(io::IO, x::Any) = show(io, x)
 show_index(io::IO, x::Slice) = show_index(io, x.indices)
 show_index(io::IO, x::LogicalIndex) = summary(io, x.mask)
-show_index(io::IO, x::OneTo) = print(io, "1:", x.stop)
+function show_index(io::IO, x::OneTo)
+    if x.stop == 1
+        return print(io, '1')
+    end
+    print(io, "1:", x.stop)
+end
 show_index(io::IO, x::Colon) = print(io, ':')
-
+function show_index(io::IO, x::Tuple)
+    if length(x) == 1
+        return show_index(io, only(x))
+    end
+    print(io, '[')
+    show_index(io, first(x))
+    for el in x[2:end]
+        print(io, ", ")
+        show_index(io, el)
+    end
+    print(io, ']')
+end
 
 function showerror(io::IO, ex::BoundsError)
     print(io, "BoundsError")
@@ -55,10 +71,24 @@ function showerror(io::IO, ex::BoundsError)
             end
             print(io, ']')
         end
+        print(io, ".\nLegal indices are ")
+        show_legal_indices(io, ex.a)
     end
     Experimental.show_error_hints(io, ex)
 end
 
+"""
+    show_legal_indices(io, x)
+
+Describe legal ways to index `x` in human-readable form. This should be a continuation of
+the sentence "Legal indices are ...". Will be shown to the user upon `BoundsError`.
+"""
+show_legal_indices(io::IO, x::Any) = print(io, "unknown.");
+function show_legal_indices(io::IO, x::AbstractArray{<:Any})
+    show_index(io, axes(x))
+    print(io, '.')
+end
+
 function showerror(io::IO, ex::TypeError)
     print(io, "TypeError: ")
     if ex.expected === Bool

base/strings/string.jl

@@ -24,6 +24,9 @@ function Base.showerror(io::IO, exc::StringIndexError)
         end
     end
 end
+function show_legal_indices(io::IO, s::AbstractString)
+    print(io, "between ", firstindex(s), " and ", thisind(s, ncodeunits(s)), '.')
+end
 
 const ByteArray = Union{CodeUnits{UInt8,String}, Vector{UInt8},Vector{Int8}, FastContiguousSubArray{UInt8,1,CodeUnits{UInt8,String}}, FastContiguousSubArray{UInt8,1,Vector{UInt8}}, FastContiguousSubArray{Int8,1,Vector{Int8}}}
 

base/tuple.jl

@@ -544,6 +544,10 @@ function in(x::Symbol, itr::Tuple{Vararg{Symbol}})
     return sym_in(x, itr)
 end
 
+function show_legal_indices(io::IO, x::Tuple)
+    show_index(io, axes(x))
+    print(io, '.')
+end
 
 """
     empty(x::Tuple)

doc/src/manual/interfaces.md

@@ -242,6 +242,7 @@ ourselves, we can officially define it as a subtype of an [`AbstractArray`](@ref
 | `axes(A)`                                    | `map(OneTo, size(A))`                  | Return a tuple of `AbstractUnitRange{<:Integer}` of valid indices                    |
 | `similar(A, ::Type{S}, inds)`              | `similar(A, S, Base.to_shape(inds))`   | Return a mutable array with the specified indices `inds` (see below)                  |
 | `similar(T::Union{Type,Function}, inds)`   | `T(Base.to_shape(inds))`               | Return an array similar to `T` with the specified indices `inds` (see below)          |
+| `show_legal_indices(io, A)` | `Base.show_index(io, axes(A)); print(io, '.');` | Human readable continuation of the sentence "Legal indices are ...", for the `BoundsError` message |
 
 If a type is defined as a subtype of `AbstractArray`, it inherits a very large set of rich behaviors
 including iteration and multidimensional indexing built on top of single-element access.  See

test/arrayops.jl

@@ -2900,29 +2900,29 @@ end
     b = IOBuffer()
     showerror(b, err)
     @test String(take!(b)) ==
-        "BoundsError: attempt to access 2×2 Matrix{Float64} at index [10, 1:2]"
+        "BoundsError: attempt to access 2×2 Matrix{Float64} at index [10, 1:2].\nLegal indices are [1:2, 1:2]."
 
     err = try x[10, trues(2)]; catch err; err; end
     b = IOBuffer()
     showerror(b, err)
     @test String(take!(b)) ==
-        "BoundsError: attempt to access 2×2 Matrix{Float64} at index [10, 2-element BitVector]"
+        "BoundsError: attempt to access 2×2 Matrix{Float64} at index [10, 2-element BitVector].\nLegal indices are [1:2, 1:2]."
 
     # Also test : directly for custom types for which it may appear as-is
     err = BoundsError(x, (10, :))
     showerror(b, err)
     @test String(take!(b)) ==
-        "BoundsError: attempt to access 2×2 Matrix{Float64} at index [10, :]"
+        "BoundsError: attempt to access 2×2 Matrix{Float64} at index [10, :].\nLegal indices are [1:3, 1:3]."
 
     err = BoundsError(x, "bad index")
     showerror(b, err)
     @test String(take!(b)) ==
-        "BoundsError: attempt to access 2×2 Matrix{Float64} at index [\"bad index\"]"
+        "BoundsError: attempt to access 2×2 Matrix{Float64} at index [\"bad index\"].\nLegal indices are [1:2, 1:2]."
 
     err = BoundsError(x, (10, "bad index"))
     showerror(b, err)
     @test String(take!(b)) ==
-        "BoundsError: attempt to access 2×2 Matrix{Float64} at index [10, \"bad index\"]"
+        "BoundsError: attempt to access 2×2 Matrix{Float64} at index [10, \"bad index\"].\nLegal indices are [1:2, 1:2]."
 end
 
 @testset "inference of Union{T,Nothing} arrays 26771" begin

test/errorshow.jl

@@ -283,6 +283,7 @@ struct Bounded  # not an AbstractArray
 end
 Base.getindex(b::Bounded, i) = checkindex(Bool, 1:b.bound, i) || throw(BoundsError(b, i))
 Base.summary(io::IO, b::Bounded) = print(io, "$(b.bound)-size Bounded")
+Base.show_legal_indices(io::IO, b::Bounded) = print(io, "1:$(b.bound).")
 let undefvar
     err_str = @except_strbt sqrt(-1) DomainError
     @test occursin("Try sqrt(Complex(x)).", err_str)
@@ -297,17 +298,17 @@ let undefvar
     @test occursin("DomainError with [0.0 -1.0 …", err_str)
 
     err_str = @except_str (1, 2, 3)[4] BoundsError
-    @test err_str == "BoundsError: attempt to access Tuple{$Int, $Int, $Int} at index [4]"
+    @test err_str == "BoundsError: attempt to access Tuple{$Int, $Int, $Int} at index [4].\nLegal indices are 1:3."
 
     err_str = @except_str [5, 4, 3][-2, 1] BoundsError
-    @test err_str == "BoundsError: attempt to access 3-element Vector{$Int} at index [-2, 1]"
+    @test err_str == "BoundsError: attempt to access 3-element Vector{$Int} at index [-2, 1].\nLegal indices are 1:3."
     err_str = @except_str [5, 4, 3][1:5] BoundsError
-    @test err_str == "BoundsError: attempt to access 3-element Vector{$Int} at index [1:5]"
+    @test err_str == "BoundsError: attempt to access 3-element Vector{$Int} at index [1:5].\nLegal indices are 1:3."
     err_str = @except_str [5, 4, 3][trues(6,7)] BoundsError
-    @test err_str == "BoundsError: attempt to access 3-element Vector{$Int} at index [6×7 BitMatrix]"
+    @test err_str == "BoundsError: attempt to access 3-element Vector{$Int} at index [6×7 BitMatrix].\nLegal indices are 1:3."
 
     err_str = @except_str Bounded(2)[3] BoundsError
-    @test err_str == "BoundsError: attempt to access 2-size Bounded at index [3]"
+    @test err_str == "BoundsError: attempt to access 2-size Bounded at index [3].\nLegal indices are 1:2."
 
     err_str = @except_str 0::Bool TypeError
     @test err_str == "TypeError: non-boolean ($Int) used in boolean context"