Fix performance without generated functions

Author: nalimilan

src/broadcast.jl

@@ -31,33 +31,29 @@ else
     using Base.Broadcast: ziptype
 end
 
-@inline @generated function broadcast_lift{F, T}(f::F, x::NTuple{1, T})
-    if null_safe_op(f.instance, eltype(T))
-        return :( Nullable(f(unsafe_get(x[1])), !isnull(x[1])) )
+@inline function broadcast_lift(f, x)
+    if null_safe_op(f, eltype(x))
+        return @compat Nullable(f(unsafe_get(x)), !isnull(x))
     else
-        U = Core.Inference.return_type(f.instance, Tuple{eltype(T)})
-        return quote
-            if isnull(x)
-                return Nullable{$U}()
-            else
-                return Nullable(f(unsafe_get(x[1])))
-            end
+        U = Core.Inference.return_type(f, Tuple{eltype(x)})
+        if isnull(x)
+            return Nullable{U}()
+        else
+            return Nullable(f(unsafe_get(x)))
         end
     end
 end
 
-@inline @generated function broadcast_lift{F, S, T}(f::F, x::Tuple{S, T})
-    if null_safe_op(f.instance, eltype(S), eltype(T))
-        return :( Nullable(f(unsafe_get(x[1]), unsafe_get(x[2])),
-                           !(isnull(x[1]) | isnull(x[2]))) )
+@inline function broadcast_lift(f, x1, x2)
+    if null_safe_op(f, eltype(x1), eltype(x2))
+        return @compat Nullable(f(unsafe_get(x1), unsafe_get(x2)),
+                                !(isnull(x1) | isnull(x2)))
     else
-        U = Core.Inference.return_type(f.instance, Tuple{eltype(S), eltype(T)})
-        return quote
-            if isnull(x[1]) | isnull(x[2])
-                return Nullable{$U}()
-            else
-                return Nullable(f(unsafe_get(x[1]), unsafe_get(x[2])))
-            end
+        U = Core.Inference.return_type(f, Tuple{eltype(x1), eltype(x2)})
+        if isnull(x1) | isnull(x2)
+            return Nullable{U}()
+        else
+            return Nullable(f(unsafe_get(x1), unsafe_get(x2)))
         end
     end
 end
@@ -67,27 +63,25 @@ eltypes(x) = Tuple{eltype(x)}
 eltypes(x, xs...) = Tuple{eltype(x), eltypes(xs...).parameters...}
 
 """
-  broadcast_lift(f, x)
+  broadcast_lift(f, xs...)
 
-Lift function `f`, passing it arguments from the tuple `x`, using standard lifting semantics:
-for a function call `f(x...)`, return null if any `x` in `x` is null; otherwise,
-return `f` applied to values of `x`.
+Lift function `f`, passing it arguments `xs...`, using standard lifting semantics:
+for a function call `f(xs...)`, return null if any `x` in `xs` is null; otherwise,
+return `f` applied to values of `xs`.
 """
-@inline @generated function broadcast_lift{F}(f::F, x::Tuple)
-    if null_safe_op(f.instance, eltypes(x).parameters...)
+@inline function broadcast_lift(f, xs...)
+    if null_safe_op(f, eltypes(xs).parameters...)
         # TODO: find a more efficient approach than mapreduce
         # (i.e. one which gets lowered to just isnull(x1) | isnull(x2) | ...)
-        return :( Nullable(f(unsafe_get.(x)), !mapreduce(isnull, |, x)) )
+        return @compat Nullable(f(unsafe_get.(xs)...), !mapreduce(isnull, |, xs))
     else
-        U = Core.Inference.return_type(f.instance, eltypes(x))
-        return quote
-            # TODO: find a more efficient approach than mapreduce
-            # (i.e. one which gets lowered to just isnull(x1) | isnull(x2) | ...)
-            if mapreduce(isnull, |, x)
-                return Nullable{$U}()
-            else
-                return Nullable(f(map(unsafe_get, x)...))
-            end
+        U = Core.Inference.return_type(f, eltypes(xs...))
+        # TODO: find a more efficient approach than mapreduce
+        # (i.e. one which gets lowered to just isnull(x1) | isnull(x2) | ...)
+        if mapreduce(isnull, |, xs)
+            return Nullable{U}()
+        else
+            return Nullable(f(map(unsafe_get, xs)...))
         end
     end
 end
@@ -109,9 +103,9 @@ of `broadcast` (i.e. without lifting).
 """
 function Base.broadcast{F, N}(f::F, As::Vararg{NullableArray, N})
     # These definitions are needed to avoid allocation due to splatting
-    f2(x1) = broadcast_lift(f, (x1,))
-    f2(x1, x2) = broadcast_lift(f, (x1, x2))
-    f2(x...) = broadcast_lift(f, x)
+    f2(x1) = broadcast_lift(f, x1)
+    f2(x1, x2) = broadcast_lift(f, x1, x2)
+    f2(x...) = broadcast_lift(f, x...)
 
     T = _default_eltype(Base.Generator{ziptype(As...), ftype(f2, As...)})
     if isleaftype(T) && !(T <: Nullable)
@@ -136,15 +130,15 @@ of `broadcast!` (i.e. without lifting).
 """
 function Base.broadcast!{F, N}(f::F, dest::NullableArray, As::Vararg{NullableArray, N})
     # These definitions are needed to avoid allocation due to splatting
-    f2(x1) = broadcast_lift(f, (x1,))
-    f2(x1, x2) = broadcast_lift(f, (x1, x2))
-    f2(x...) = broadcast_lift(f, x)
+    f2(x1) = broadcast_lift(f, x1)
+    f2(x1, x2) = broadcast_lift(f, x1, x2)
+    f2(x...) = broadcast_lift(f, x...)
     call_broadcast(f2, dest, As...)
 end
 
 # To fix ambiguity
 function Base.broadcast!{F}(f::F, dest::NullableArray)
-    f2() = broadcast_lift(f, ())
+    f2() = broadcast_lift(f)
     call_broadcast(f2, dest)
 end