Resolve the two new method ambiguities flagged by Aqua on Julia 1.11

The DataStyle x DataStyle method was ambiguous with the DataStyle x
AbstractArrayStyle{0} method because the existing DataStyle{0}
disambiguator did not cover their full type intersection: typeintersect
drops the DataLayout bound on the second style's layout type, so the
disambiguator needs an unconstrained typevar there (and the diagonal
bound on the first argument). The scalar-broadcast copyto! was ambiguous
with BlockArrays' copyto! for AbstractBlockStyle{0}, resolved with an
explicit method like the existing StaticArrayStyle{0} one.

Verified with Aqua.detect_ambiguities filtered as in test/aqua.jl:
27 -> 25 on Julia 1.11.9 (CI failed at 27 > 26) and 25 -> 24 on Julia
1.10, with exactly the two new pairs removed and none added; dispatch
behavior verified unchanged for 0-dimensional style combinations.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: dennisYatunin

src/DataLayouts/DataLayouts.jl

@@ -3,6 +3,7 @@ module DataLayouts
 import Base: @propagate_inbounds
 import LLVM: unsafe_load
 import StaticArrays
+import BlockArrays
 import Adapt
 
 import ClimaComms

src/DataLayouts/broadcast.jl

@@ -21,7 +21,13 @@ Broadcast.BroadcastStyle(::DataStyle{<:Any, D1}, ::DataStyle{<:Any, D2}) where {
 Broadcast.BroadcastStyle(style::DataStyle, ::Broadcast.Style{Tuple}) = style
 Broadcast.BroadcastStyle(style::DataStyle, ::Broadcast.AbstractArrayStyle{0}) = style
 Broadcast.BroadcastStyle(style::DataStyle, ::Broadcast.DefaultArrayStyle{0}) = style
-Broadcast.BroadcastStyle(style::DataStyle, ::DataStyle{0}) = style
+# The unconstrained typevar D2 is required for this method to cover the full
+# intersection of the two ambiguous signatures above (typeintersect drops the
+# DataLayout bound on the second style's layout type).
+Broadcast.BroadcastStyle(
+    style::DataStyle{N, D1},
+    ::DataStyle{0, D2},
+) where {N, D1 <: DataLayout{<:Any, N}, D2} = style
 
 # Enable automatic nested broadcasting over supported types of iterators.
 @inline Broadcast.broadcastable(data::DataLayout) =

src/DataLayouts/loops.jl

@@ -222,8 +222,13 @@ end
 # scalar broadcast runs in a pointwise loop. materialize! attaches dest's axes so Base
 # evaluates at every dest index, but foreach_point's single-point views lack dest indices,
 # so the axes are removed and the broadcast runs at index 1 (Base's instantiate likewise
-# leaves scalar broadcasts axis-free). StaticArrayStyle{0} avoids a StaticArrays ambiguity.
-for S in (:(<:Broadcast.AbstractArrayStyle{0}), :(<:StaticArrays.StaticArrayStyle{0}))
+# leaves scalar broadcasts axis-free). The StaticArrayStyle{0} and AbstractBlockStyle{0}
+# methods avoid ambiguities with StaticArrays and BlockArrays.
+for S in (
+    :(<:Broadcast.AbstractArrayStyle{0}),
+    :(<:StaticArrays.StaticArrayStyle{0}),
+    :(<:BlockArrays.AbstractBlockStyle{0}),
+)
     @eval @inline Base.copyto!(dest::DataLayout, bc::Broadcast.Broadcasted{$S}; kwargs...) =
         if bc.f === identity && isone(length(bc.args)) && Broadcast.isflat(bc)
             @inbounds arg = first(bc.args)