Avoid integer overflow when constructing arrays (#26)

* Avoid integer overflow when constructing arrays

* reimplement `checked_dims` instead of using Julia internals

`Core.checked_dims` isn't public.

* Test more constructors

* weird codecov fix

* One more constructor test

* weird codecov fix

---------

Co-authored-by: Neven Sajko <s@purelymail.com>

Author: giordano

src/FixedSizeArrays.jl

@@ -14,7 +14,7 @@ const FixedSizeVector{T} = FixedSizeArray{T,1}
 const FixedSizeMatrix{T} = FixedSizeArray{T,2}
 
 function FixedSizeArray{T,N}(::UndefInitializer, size::NTuple{N,Int}) where {T,N}
-    FixedSizeArray{T,N}(Memory{T}(undef, prod(size)), size)
+    FixedSizeArray{T,N}(Memory{T}(undef, checked_dims(size)), size)
 end
 function FixedSizeArray{T,N}(::UndefInitializer, size::Vararg{Int,N}) where {T,N}
     FixedSizeArray{T,N}(undef, size)
@@ -38,6 +38,24 @@ end
 
 Base.isassigned(a::FixedSizeArray, i::Int) = isassigned(a.mem, i)
 
+# safe product of a tuple of integers, for calculating dimensions size
+
+checked_dims_impl(a::Int, ::Tuple{}) = a
+function checked_dims_impl(a::Int, t::Tuple{Int,Vararg{Int,N}}) where {N}
+    b = first(t)
+    (m, o) = Base.Checked.mul_with_overflow(a, b)
+    o && throw(ArgumentError("array dimensions too great, can't represent length"))
+    r = Base.tail(t)::NTuple{N,Int}
+    checked_dims_impl(m, r)::Int
+end
+
+checked_dims(::Tuple{}) = 1
+function checked_dims(t::Tuple{Int,Vararg{Int,N}}) where {N}
+    a = first(t)
+    r = Base.tail(t)::NTuple{N,Int}
+    checked_dims_impl(a, r)::Int
+end
+
 # broadcasting
 
 function Base.BroadcastStyle(::Type{<:FixedSizeArray})

test/runtests.jl

@@ -2,11 +2,39 @@ using Test
 using FixedSizeArrays
 import Aqua
 
+const checked_dims = FixedSizeArrays.checked_dims
+
+function allocated(f::F, args::Vararg{Any,N}) where {F,N}
+    @allocated f(args...)
+end
+
 @testset "FixedSizeArrays" begin
     @testset "Aqua.jl" begin
         Aqua.test_all(FixedSizeArrays)
     end
 
+    @testset "Constructors" begin
+        @test FixedSizeArray{Float64,0}(undef) isa FixedSizeArray{Float64,0}
+        @test FixedSizeArray{Float64,0}(undef, ()) isa FixedSizeArray{Float64,0}
+        @test_throws ArgumentError FixedSizeArray{Float64,1}(undef, typemin(Int))
+        @test_throws ArgumentError FixedSizeArray{Float64,2}(undef, typemax(Int), typemax(Int))
+        @test_throws ArgumentError FixedSizeArray{Float64,3}(undef, typemax(Int), typemax(Int), 2)
+        @test_throws ArgumentError FixedSizeArray{Float64,4}(undef, typemax(Int), typemax(Int), 2, 4)
+    end
+
+    @testset "safe computation of length from dimensions size" begin
+        @test isone(checked_dims(()))
+        for n ∈ 0:30
+            t = Tuple(1:n)
+            if 20 < n
+                @test_throws ArgumentError checked_dims(t)
+            else
+                @test factorial(n) == prod(t) == @inferred checked_dims(t)
+                @test iszero(allocated(checked_dims, t))
+            end
+        end
+    end
+
     @testset "FixedSizeVector" begin
         v = FixedSizeVector{Float64}(undef, 3)
         @test length(v) == 3