some more improvements

- avoid assuming the tuples have the same eltype
- coerce the inputs to simpler representations before printing, if
  unambiguous
- update a couple more error messages with the same text
- use string builder, instead of repeated concatenation

Author: vtjnash

base/indices.jl

@@ -106,22 +106,33 @@ IndexStyle(::IndexStyle, ::IndexStyle) = IndexCartesian()
 
 promote_shape(::Tuple{}, ::Tuple{}) = ()
 
-# Consistent error message for promote_shape mismatch, hiding implementation details like
+# Consistent error message for promote_shape mismatch, hiding type details like
 # OneTo. When b ≡ nothing, it is omitted; i can be supplied for an index.
-function throw_promote_shape_mismatch(a::Tuple{T,Vararg{T}},
-                                      b::Union{Nothing,Tuple{T,Vararg{T}}},
-                                      i = nothing) where {T}
-    _has_axes = T <: AbstractUnitRange
-    _normalize(d) = map(x -> _has_axes ? (firstindex(x):lastindex(x)) : x, d)
-    _things = _has_axes ? "axes" : "size"
-    msg = "a has $(_things) $(_normalize(a))"
+function throw_promote_shape_mismatch(a::Tuple, b::Union{Nothing,Tuple}, i = nothing)
+    if a isa Tuple{Vararg{Base.OneTo}} && (b === nothing || b isa Tuple{Vararg{Base.OneTo}})
+        a = map(lastindex, a)::Dims
+        b === nothing || (b = map(lastindex, b)::Dims)
+    end
+    _has_axes = !(a isa Dims && (b === nothing || b isa Dims))
+    if _has_axes
+        _normalize(d) = map(x -> firstindex(x):lastindex(x), d)
+        a = _normalize(a)
+        b === nothing || (b = _normalize(b))
+        _things = "axes "
+    else
+        _things = "size "
+    end
+    msg = IOBuffer()
+    print(msg, "a has ", _things)
+    print(msg, a)
     if b ≢ nothing
-        msg *= ", b has $(_things) $(_normalize(b))"
+        print(msg, ", b has ", _things)
+        print(msg, b)
     end
     if i ≢ nothing
-        msg *= ", mismatch at $(i)"
+        print(msg, ", mismatch at dim ", i)
     end
-    throw(DimensionMismatch(msg))
+    throw(DimensionMismatch(String(take!(msg))))
 end
 
 function promote_shape(a::Tuple{Int,}, b::Tuple{Int,})

stdlib/LinearAlgebra/src/matmul.jl

@@ -184,7 +184,7 @@ function Base.muladd(A::AbstractMatrix, y::AbstractVecOrMat, z::Union{Number, Ab
     end
     for d in ndims(Ay)+1:ndims(z)
         # Similar error to what Ay + z would give, to match (Any,Any,Any) method:
-        size(z,d) > 1 && throw(DimensionMismatch(string("dimensions must match: z has dims ",
+        size(z,d) > 1 && throw(DimensionMismatch(string("z has dims ",
             axes(z), ", must have singleton at dim ", d)))
     end
     Ay .+ z
@@ -197,7 +197,7 @@ function Base.muladd(u::AbstractVector, v::AdjOrTransAbsVec, z::Union{Number, Ab
     end
     for d in 3:ndims(z)
         # Similar error to (u*v) + z:
-        size(z,d) > 1 && throw(DimensionMismatch(string("dimensions must match: z has dims ",
+        size(z,d) > 1 && throw(DimensionMismatch(string("z has dims ",
             axes(z), ", must have singleton at dim ", d)))
     end
     (u .* v) .+ z

stdlib/LinearAlgebra/src/structuredbroadcast.jl

@@ -251,6 +251,8 @@ end
 # We can also implement `map` and its promotion in terms of broadcast with a stricter dimension check
 function map(f, A::StructuredMatrix, Bs::StructuredMatrix...)
     sz = size(A)
-    all(map(B->size(B)==sz, Bs)) || throw(DimensionMismatch("dimensions must match"))
+    for B in Bs
+        size(B) == sz || Base.throw_promote_shape_mismatch(sz, size(B))
+    end
     return f.(A, Bs...)
 end

stdlib/LinearAlgebra/test/structuredbroadcast.jl

@@ -142,6 +142,11 @@ end
             @test map!(*, Z, X, Y) == broadcast(*, fX, fY)
         end
     end
+    # these would be valid for broadcast, but not for map
+    @test_throws DimensionMismatch map(+, D, Diagonal(rand(1)))
+    @test_throws DimensionMismatch map(+, D, Diagonal(rand(1)), D)
+    @test_throws DimensionMismatch map(+, D, D, Diagonal(rand(1)))
+    @test_throws DimensionMismatch map(+, Diagonal(rand(1)), D, D)
 end
 
 @testset "Issue #33397" begin