Test for unbound args (#891)

* Test for unbound args

* Two unbound args

* Zero unbound args

Author: chriselrod

src/MVector.jl

@@ -1,4 +1,3 @@
-
 # Some more advanced constructor-like functions
 @inline zeros(::Type{MVector{N}}) where {N} = zeros(MVector{N,Float64})
 @inline ones(::Type{MVector{N}}) where {N} = ones(MVector{N,Float64})

src/abstractarray.jl

@@ -127,7 +127,7 @@ When `a` is an instance or a concrete type the element type `eltype(a)` is
 used. However, when `a` is a `UnionAll` type such as `SMatrix{2,2}`, the
 promoted type of `elements` is used instead.
 """
-@inline function _construct_similar(a, s::Size, elements::NTuple{L,ET}) where {L,ET}
+@inline function _construct_similar(a, s::Size, elements::Tuple{ET,Vararg{ET,L}}) where {L,ET}
     similar_type(a, _eltype_or(a, ET), s)(elements)
 end
 

src/matrix_multiply_add.jl

@@ -193,8 +193,8 @@ istranspose(::TSize{<:Any,T}) where T = (T === :transpose)
 size(::TSize{S}) where S = S
 Size(::TSize{S}) where S = Size{S}()
 access_type(::TSize{<:Any,T}) where T = T
-Base.transpose(::TSize{S,:transpose}) where {S,T} = TSize{reverse(S),:any}()
-Base.transpose(::TSize{S,:any}) where {S,T} = TSize{reverse(S),:transpose}()
+Base.transpose(::TSize{S,:transpose}) where {S} = TSize{reverse(S),:any}()
+Base.transpose(::TSize{S,:any}) where {S} = TSize{reverse(S),:transpose}()
 
 # Get the parent of transposed arrays, or the array itself if it has no parent
 # Different from Base.parent because we only want to get rid of Transpose and Adjoint

test/runtests.jl

@@ -46,6 +46,7 @@ if TEST_GROUP ∈ ["", "all", "group-A"]
     end
 
     addtests("ambiguities.jl")
+    addtests("unbound_args.jl")
     addtests("custom_types.jl")
     addtests("convert.jl")
     addtests("core.jl")

test/unbound_args.jl

@@ -0,0 +1,9 @@
+
+# Some unbound_args are hard to avoid, e.g. `SVector{N}(::NTuple{N,T})`
+# if `N == 0`, then `T` is unbound. We could disallow calling
+# `SVector{0}(())`, but throwing a `T not defined` error seems benign.
+# Working around this, e.g. with `SVector{N}(::Tuple{T,Vararg{T,Nm1}}) where {N,T,Nm1}`
+# and then asserting `N == Nm1+1` also seems reasonable (the compiler should eliminate the assert).
+const allowable_unbound_args = 0
+
+@test length(detect_unbound_args(StaticArrays)) <= allowable_unbound_args