Remove unecessary apply optimization

Author: José Valim

lib/elixir/lib/kernel.ex

@@ -354,28 +354,34 @@ defmodule Kernel do
 
   @doc """
   Invokes the given `fun` with the array of arguments `args`.
+  Inlines to `:erlang.apply/2`.
 
   ## Examples
 
       iex> apply(fn x -> x * 2 end, [2])
       4
 
   """
-  def apply(fun, args) do
-    :erlang.apply(fun, args)
+  defmacro apply(fun, args) do
+    quote do
+      :erlang.apply(unquote(fun), unquote(args))
+    end
   end
 
   @doc """
   Invokes the given `fun` from `module` with the array of arguments `args`.
+  Inlines to `:erlang.apply/3`.
 
   ## Examples
 
       iex> apply(Enum, :reverse, [[1, 2, 3]])
       [3,2,1]
 
   """
-  def apply(module, fun, args) do
-    :erlang.apply(module, fun, args)
+  defmacro apply(module, fun, args) do
+    quote do
+      :erlang.apply(unquote(module), unquote(fun), unquote(args))
+    end
   end
 
   @doc """

lib/elixir/src/elixir_dispatch.erl

@@ -398,6 +398,8 @@ in_elixir_macros() ->
 in_erlang_functions() ->
   [
     { abs, 1 },
+    { apply, 2 },
+    { apply, 3 },
     { atom_to_list, 1 },
     { binary_part, 3 },
     { binary_to_float, 1 },
@@ -491,8 +493,6 @@ in_erlang_macros() ->
     {'>=',2},
     {'@',1},
     {'and',2},
-    {apply,2},
-    {apply,3},
     {'case',2},
     {def,1},
     {def,2},

lib/elixir/src/elixir_macros.erl

@@ -2,7 +2,7 @@
 %% but do not since they need to be implemented in Erlang.
 -module(elixir_macros).
 -export([translate/2]).
--import(elixir_translator, [translate_each/2, translate_args/2, translate_apply/7]).
+-import(elixir_translator, [translate_each/2]).
 -import(elixir_scope, [umergec/2, umergea/2]).
 -import(elixir_errors, [compile_error/3, syntax_error/3, syntax_error/4,
   assert_no_function_scope/3, assert_module_scope/3, assert_no_match_or_guard_scope/3]).
@@ -184,17 +184,6 @@ translate({Kind, Meta, [Call, Expr]}, S) when ?defs(Kind) ->
                    (not QC#elixir_quote.unquoted) andalso (not QE#elixir_quote.unquoted),
   { elixir_def:wrap_definition(Kind, Meta, TCall, TExpr, CheckClauses, SE), SE };
 
-%% Apply - Optimize apply by checking what doesn't need to be dispatched dynamically
-
-translate({ apply, Meta, [Left, Right, Args] }, S) when is_list(Args) ->
-  { TLeft,  SL } = translate_each(Left, S),
-  { TRight, SR } = translate_each(Right, umergec(S, SL)),
-  translate_apply(Meta, TLeft, TRight, Args, S, SL, SR);
-
-translate({ apply, Meta, Args }, S) ->
-  { TArgs, NS } = translate_args(Args, S),
-  { ?wrap_call(?line(Meta), erlang, apply, TArgs), NS };
-
 translate({ Name, Meta, Args }, S) ->
   syntax_error(Meta, S#elixir_scope.file,
                "invalid arguments for macro ~ts/~B", [Name, length(Args)]).

lib/elixir/src/elixir_translator.erl

@@ -2,8 +2,7 @@
 %% overriden are defined in this file.
 -module(elixir_translator).
 -export([forms/4, 'forms!'/4]).
--export([translate/2, translate_each/2, translate_arg/2,
-         translate_args/2, translate_apply/7]).
+-export([translate/2, translate_each/2, translate_arg/2, translate_args/2]).
 -import(elixir_scope, [umergev/2, umergec/2, umergea/2]).
 -import(elixir_errors, [syntax_error/3, syntax_error/4,
   compile_error/3, compile_error/4,
@@ -386,9 +385,22 @@ translate_each({ Atom, Meta, Args }, S) when is_atom(Atom), is_list(Meta), is_li
 translate_each({ { '.', _, [Left, Right] }, Meta, Args }, S)
     when (is_tuple(Left) orelse is_atom(Left)), is_atom(Right), is_list(Meta), is_list(Args) ->
   { TLeft,  SL } = translate_each(Left, S),
-
   { TRight, SR } = translate_each(Right, umergec(S, SL)),
-  Callback = fun() -> translate_apply(Meta, TLeft, TRight, Args, S, SL, SR) end,
+
+  Callback = fun() ->
+    case TLeft of
+      { atom, _, Receiver } ->
+        Tuple = { element(3, TRight), length(Args) },
+        elixir_lexical:record_remote(Receiver, S#elixir_scope.lexical_tracker),
+        elixir_tracker:record_remote(Tuple, Receiver, S#elixir_scope.module, S#elixir_scope.function);
+      _ ->
+        ok
+    end,
+
+    Line = ?line(Meta),
+    { TArgs, SA } = translate_args(Args, umergec(S, SR)),
+    { { call, Line, { remote, Line, TLeft, TRight }, TArgs }, umergev(SL, umergev(SR, SA)) }
+  end,
 
   case TLeft of
     { atom, _, Receiver } ->
@@ -584,42 +596,6 @@ translate_args(Args, S) ->
   { TArgs, { SC, SV } } = lists:mapfoldl(fun translate_arg/2, {S, S}, Args),
   { TArgs, umergea(SV, SC) }.
 
-%% Translate apply
-%% Used by both apply and external function invocation macros.
-
-translate_apply(Meta, TLeft, TRight, Args, S, SL, SR) ->
-  Line = ?line(Meta),
-
-  Optimize = case (Args == []) orelse lists:last(Args) of
-    { '|', _, _ } -> false;
-    _ ->
-      case TRight of
-        { atom, _, _ } -> true;
-        _ -> false
-      end
-  end,
-
-  case Optimize of
-    true ->
-      %% Register the remote
-      case TLeft of
-        { atom, _, Receiver } ->
-          Tuple = { element(3, TRight), length(Args) },
-          elixir_lexical:record_remote(Receiver, S#elixir_scope.lexical_tracker),
-          elixir_tracker:record_remote(Tuple, Receiver, S#elixir_scope.module, S#elixir_scope.function);
-        _ ->
-          ok
-      end,
-
-      { TArgs, SA } = translate_args(Args, umergec(S, SR)),
-      FS = umergev(SL, umergev(SR,SA)),
-      { { call, Line, { remote, Line, TLeft, TRight }, TArgs }, FS };
-    false ->
-      { TArgs, SA } = translate_each(Args, umergec(S, SR)),
-      FS = umergev(SL, umergev(SR,SA)),
-      { ?wrap_call(Line, erlang, apply, [TLeft, TRight, TArgs]), FS }
-  end.
-
 %% __op__ helpers
 
 assert_no_match_scope_for_bin_op(Meta, Op, S)