Fix assignment to 0-dim array indexed by CartesianIndices{0}

[jmert]

The change in PR #31214 replaced CartesianIndices in the indexing tuple with their constituent ranges. This broke assignment to 0-dimensional arrays which have been indexed by a CartesianIndices{0}, e.g.

julia> A = fill(0.0);

julia> I = CartesianIndices(size(A));

julia> x = fill!(similar(A), 1.0);

# On v1.3
julia> A[I] = x
0-dimensional Array{Float64,0}:
1.0

# On master
julia> A[I] = x
ERROR: MethodError: Cannot `convert` an object of type Array{Float64,0} to an object of type Float64
...

This is because previously the CartesianIndices{0} (hereafter CI0) was preserved through the call to to_indices():

# On v1.3
julia> to_indices(A, (I,))
(CartesianIndex(),)

julia> to_indices(A, (I,I))
(CartesianIndex(), CartesianIndex())

julia> to_indices(A, (I,I,I))
(CartesianIndex(), CartesianIndex(), CartesianIndex())

but now the empty tuple is returned instead:

# On master
julia> to_indices(A, (I,))
()

julia> to_indices(A, (I,I))
()

julia> to_indices(A, (I,I,I))
()

and that changes which internal implementation of setindex! is dispatched to.

This PR fixes the issue by tweaking the tuple reduction performed by to_indices(). The result is that
during the tuple reduction, a case where only [trailing] CI0s remain is shortcut and returns just a single CI0 index.

With this PR:

julia> A[I] = x
0-dimensional Array{Float64,0}:
1.0

julia> to_indices(A, (I,))
(fill(CartesianIndex()),)

julia> to_indices(A, (I,I))
(fill(CartesianIndex()),)

julia> to_indices(A, (I,I,I))
(fill(CartesianIndex()),)

The one thing I couldn't figure out is how to avoid an unnecessary trailing CI0 if a concrete index precedes it — (my attempts lead to to_indices() method ambiguities) — but there's always at most a single unnecessary trailing CI0.

julia> B = [1.0]
1-element Array{Float64,1}:
 1.0

julia> to_indices(B, (1, I))
(1, fill(CartesianIndex()))

julia> to_indices(B, (1, I, I))
(1, fill(CartesianIndex()))

julia> to_indices(B, (I, 1, I))
(1, fill(CartesianIndex()))

julia> to_indices(B, (I, I, 1, I))
(1, fill(CartesianIndex()))

julia> to_indices(B, (I, I, I, 1))
(1,)

[jmert]

I found another case that has regressed, and this PR right now doesn't fix.

julia> I = CartesianIndices(())
0-dimensional CartesianIndices{0,Tuple{}}:
CartesianIndex()

# On v1.3
julia> setindex!(zeros(2), fill(1.0), I, 1)
2-element Array{Float64,1}:
 1.0
 0.0

# On master
julia> setindex!(zeros(2), fill(1.0), I, 1)
ERROR: MethodError: Cannot `convert` an object of type Array{Float64,0} to an object of type Float64
...

[jmert]

It appears simply preserving all instances of CartesianIndices(()) in the indexing tuple fixes the case in my previous comment. I've added a few new tests for that as well.

[mbauman]

Ah, very nice, thank you! There's an ambiguity when there are no indices — was this a scalar assignment or a non scalar assignment? #24086 is the root cause here, but this is a great fix. Thanks!

[jmert]

Correct me if I'm wrong, but I don't think this PR needs to be backported since #31214 was only merged after the v1.4 branch (assuming I'm reading the tag/branch "breadcrumb" in Github's view of f579d14 correctly).

[mbauman]

Right you are. Thanks again!