Add informative error when threading VoA{SArray} without Polyester

When Polyester is not loaded and a user requests threaded FastBroadcast
on VectorOfArray{SArray}, throw an error explaining they need to load
Polyester.jl. Also fix tests to use Vector-of-SVector construction
(not Matrix-of-SVector) to properly exercise the SArray-specific path.

Co-Authored-By: Chris Rackauckas <accounts@chrisrackauckas.com>
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: ChrisRackauckas

ext/RecursiveArrayToolsFastBroadcastExt.jl

@@ -27,14 +27,20 @@ const AbstractVectorOfSArray = AbstractVectorOfArray{
     return dst
 end
 
-# Fallback for VectorOfArray: the generic threaded path splits along the last
-# axis via views, which does not correctly partition work for VectorOfArray.
-# Fall back to serial broadcasting. The RecursiveArrayToolsFastBroadcastPolyesterExt
-# extension provides proper Polyester-based threading when Polyester is loaded.
+# Fallback for non-SArray VectorOfArray: the generic threaded path splits along
+# the last axis via views, which does not correctly partition work for
+# VectorOfArray. Fall back to serial broadcasting.
+# For SArray VectorOfArray, throw an informative error telling the user to
+# load Polyester.jl for threaded broadcasting.
 @inline function FastBroadcast.fast_materialize!(
         ::Threaded, dst::AbstractVectorOfArray,
         bc::Broadcast.Broadcasted
     )
+    if dst isa AbstractVectorOfSArray && !RecursiveArrayTools.POLYESTER_LOADED[]
+        error("Threaded FastBroadcast on VectorOfArray{SArray} requires Polyester.jl. " *
+              "Add `using Polyester` to enable threaded broadcasting, or use " *
+              "`@.. thread=false` for serial broadcasting.")
+    end
     return FastBroadcast.fast_materialize!(Serial(), dst, bc)
 end
 

ext/RecursiveArrayToolsFastBroadcastPolyesterExt.jl

@@ -6,6 +6,9 @@ using FastBroadcast: Serial, Threaded
 using Polyester
 using StaticArraysCore
 
+# Signal to the base FastBroadcast extension that Polyester threading is available.
+RecursiveArrayTools.POLYESTER_LOADED[] = true
+
 const AbstractVectorOfSArray = AbstractVectorOfArray{
     T, N, <:AbstractVector{<:StaticArraysCore.SArray},
 } where {T, N}

src/RecursiveArrayTools.jl

@@ -142,6 +142,11 @@ module RecursiveArrayTools
 
     export ArrayPartition, AP, NamedArrayPartition
 
+    # Flag set to `true` by RecursiveArrayToolsFastBroadcastPolyesterExt when
+    # Polyester is loaded. Checked by the FastBroadcast ext to decide whether
+    # to throw an informative error on threaded VoA{SArray} operations.
+    const POLYESTER_LOADED = Ref(false)
+
     include("precompilation.jl")
 
 end # module

test/interface_tests.jl

@@ -305,15 +305,15 @@ end
         :RecursiveArrayToolsFastBroadcastPolyesterExt
     ) !== nothing
 
-    # Test basic threaded broadcast with Polyester
-    u_p = VectorOfArray(fill(SVector(2.0, 3.0), 3, 3))
+    # Test basic threaded broadcast with Polyester (Vector-of-SVector storage)
+    u_p = VectorOfArray([SVector(2.0, 3.0) for _ in 1:9])
     v_p = copy(u_p)
     @.. thread = true v_p = v_p + u_p
     @test all(x -> x == SVector(4.0, 6.0), v_p.u)
 
     # Test with larger array to exercise Polyester batching
-    u_large = VectorOfArray(fill(SVector(1.0, 1.0, 1.0), 100))
-    v_large = VectorOfArray(fill(SVector(0.0, 0.0, 0.0), 100))
+    u_large = VectorOfArray([SVector(1.0, 1.0, 1.0) for _ in 1:100])
+    v_large = VectorOfArray([SVector(0.0, 0.0, 0.0) for _ in 1:100])
     @.. thread = true v_large = u_large * 2.0
     @test all(x -> x == SVector(2.0, 2.0, 2.0), v_large.u)
 end