Inference works for much more arguments

Author: emmt

NEWS.md

@@ -9,6 +9,9 @@
 - Methods `as(T)`, `nearest(T)`, `convert_bare_type(T)`, `convert_real_type(T)`,
   `convert_floating_point_type(T)`, and `convert_eltype(T)` yield converters to type `T`.
 
+- Inference works for more than 3 arguments for `bare_type(args...)`,
+  `real_type(args...)`, and `floating_point_type(args...)`.
+
 # Version 1.4.2
 
 - New `nearest(T,x)` method to return the value of type `T` that is the nearest to `x`.

src/TypeUtils.jl

@@ -738,7 +738,7 @@ for f in (:bare_type, :real_type)
     @eval begin
         $f(a, b) = promote_type($f(a), $f(b))
         $f(a, b, c) = promote_type($f(a), $f(b), $f(c))
-        @inline $f(a, b, c...) = promote_type($f(a), $f(b), map($f, c)...)
+        @inline $f(a, b, c...) = promote_type($f(a, b), $f(c...))
     end
 end
 

test/runtests.jl

@@ -121,15 +121,15 @@ same_value_and_type(x::T, y::T) where {T} = (x === y) || (x == y)
         @test (2:5, -1:4) === @inferred as(Tuple, CartesianIndices((2:5, -1:4)))
         @test (2:5, -1:4) === @inferred as(NTuple{2}, CartesianIndices((2:5, -1:4)))
 
-        @test CartesianIndex()         === @inferred as(CartesianIndex,())
+        @test CartesianIndex()        === @inferred as(CartesianIndex,())
         @test CartesianIndex((1,2,3)) === @inferred as(CartesianIndex, CartesianIndex((1,2,3)))
         @test CartesianIndex((1,2,3)) === @inferred as(CartesianIndex{3}, CartesianIndex((1,2,3)))
         @test CartesianIndex((1,2,3)) === @inferred as(CartesianIndex, (0x1,2,Int16(3)))
         @test CartesianIndex((1,2,3)) === @inferred as(CartesianIndex{3}, (0x1,2,Int16(3)))
 
-        @test CartesianIndices(()) === @inferred as(CartesianIndices,())
-        @test CartesianIndices((2:3,6)) === @inferred as(CartesianIndices,(2:3,6))
-        @test CartesianIndices((2:3,6)) === @inferred as(CartesianIndices,CartesianIndices((2:3,6)))
+        @test CartesianIndices(())           === @inferred as(CartesianIndices,())
+        @test CartesianIndices((2:3,6))      === @inferred as(CartesianIndices,(2:3,6))
+        @test CartesianIndices((2:3,6))      === @inferred as(CartesianIndices,CartesianIndices((2:3,6)))
         @test CartesianIndices((2:3,6,-1:4)) === @inferred as(CartesianIndices{3},(2:3,6,-1:4))
         @test CartesianIndices((2:3,6,-1:4)) === @inferred as(CartesianIndices{3},CartesianIndices((2:3,6,-1:4)))
 
@@ -527,12 +527,13 @@ same_value_and_type(x::T, y::T) where {T} = (x === y) || (x == y)
         @test_throws ErrorException bare_type(AbstractString)
 
         # bare_type with multiple arguments
-        @test Float32                                 === @inferred bare_type(1, 0f0)
-        @test promote_type(Int, typeof(pi))           === @inferred bare_type(Int, pi)
-        @test promote_type(Int, typeof(pi), Float64)  === @inferred bare_type(4, pi, 1.0)
-        @test promote_type(Int, Int8, Float32)        === @inferred bare_type(Int, Int8, Float32)
-        @test promote_type(Int, Int8, Float32)        === @inferred bare_type(Int, Int8, Float32)
-        @test promote_type(Int, Int8, Int16, Float32) === #=@inferred=# bare_type(Int, Int8, Int16, Float32)
+        @test Float32                                               === @inferred bare_type(1, 0f0)
+        @test promote_type(Int, typeof(pi))                         === @inferred bare_type(Int, pi)
+        @test promote_type(Int, typeof(pi), Float64)                === @inferred bare_type(4, pi, 1.0)
+        @test promote_type(Int, Int8, Float32)                      === @inferred bare_type(Int, Int8, Float32)
+        @test promote_type(Int, Int8, Int16, Float32)               === @inferred bare_type(Int, Int8, Int16, Float32)
+        @test promote_type(Int, Int8, Int16, Float32, Bool)         === @inferred bare_type(Int, Int8, Int16, Float32, Bool)
+        @test promote_type(Int, Int8, Int16, Float32, Bool, UInt16) === @inferred bare_type(Int, Int8, Int16, Float32, Bool, UInt16)
 
         # default implementation
         @test Float32 === @inferred bare_type(MyNumber(1.2f0))
@@ -583,12 +584,14 @@ same_value_and_type(x::T, y::T) where {T} = (x === y) || (x == y)
         @test_throws ErrorException real_type(AbstractString)
 
         # real_type with multiple arguments
-        @test Float32                                 === @inferred real_type(1, 0f0)
-        @test promote_type(Int, typeof(pi))           === @inferred real_type(Int, pi)
-        @test promote_type(Int, typeof(pi), Float64)  === @inferred real_type(4, pi, 1.0)
-        @test promote_type(Int, Int8, Float32)        === @inferred real_type(Int, Int8, Float32)
-        @test promote_type(Int, Int8, Float32)        === @inferred real_type(Int, Int8, Float32)
-        @test promote_type(Int, Int8, Int16, Float32) === #=@inferred=# real_type(Int, Int8, Complex{Int16}, Float32)
+        @test Float32                                               === @inferred real_type(1, 0f0)
+        @test promote_type(Int, typeof(pi))                         === @inferred real_type(Int, pi)
+        @test promote_type(Int, typeof(pi), Float64)                === @inferred real_type(4, pi, 1.0)
+        @test promote_type(Int, Int8, Float32)                      === @inferred real_type(Int, Int8, Float32)
+        @test promote_type(Int, Int8, Int16, Float32)               === @inferred real_type(Int, Int8, Int16, Float32)
+        @test promote_type(Int, Int8, Int16, Float32, Bool)         === @inferred real_type(Int, Int8, Int16, Float32, Bool)
+        @test promote_type(Int, Int8, Int16, Float32, Bool, UInt16) === @inferred real_type(Int, Int8, Int16, Float32, Bool, UInt16)
+        @test promote_type(Int, Int8, Int16, Float32, Bool, UInt16) === @inferred real_type(Int, Int8, Int16, Complex{Float32}, Bool, UInt16)
 
         # default implementation
         @test Float32 === @inferred real_type(MyNumber(1.2f0))
@@ -630,7 +633,8 @@ same_value_and_type(x::T, y::T) where {T} = (x === y) || (x == y)
         @test float(Int16)  === @inferred floating_point_type(Int16)
         @test Float32       === @inferred floating_point_type(Int16, Float32)
         @test Float64       === @inferred floating_point_type(Int16, Float32, Complex{Float64})
-        @test Float32       === #=@inferred=# floating_point_type(Int16, Float32, Complex{Float16}, 0x1)
+        @test Float32       === @inferred floating_point_type(Int16, Float32, Complex{Float16}, 0x1)
+        @test Float32       === @inferred floating_point_type(Int16, Float32, Complex{Float16}, 0x1, -42)
 
         # convert_floating_point_type
         @test -1.0  === @inferred convert_floating_point_type(Int, -1)