Deprecate Macro.extract_args/1

Author: José Valim

lib/elixir/lib/behaviour.ex

@@ -66,19 +66,19 @@ defmodule Behaviour do
   end
 
   defp do_defcallback(fun, spec, caller) do
-    case Macro.extract_args(fun) do
+    case Macro.decompose_call(fun) do
       { name, args } ->
         do_callback(:def, name, args, name, length(args), spec, caller)
-      :error ->
+      _ ->
         raise ArgumentError, message: "invalid syntax in defcallback #{Macro.to_string(fun)}"
     end
   end
 
   defp do_defmacrocallback(fun, spec, caller) do
-    case Macro.extract_args(fun) do
+    case Macro.decompose_call(fun) do
       { name, args } ->
         do_callback(:defmacro, :"MACRO-#{name}", [quote(do: env :: Macro.Env.t)|args], name, length(args), spec, caller)
-      :error ->
+      _ ->
         raise ArgumentError, message: "invalid syntax in defmacrocallback #{Macro.to_string(fun)}"
     end
   end

lib/elixir/lib/kernel.ex

@@ -3518,9 +3518,9 @@ defmodule Kernel do
       append_first = Keyword.get(opts, :append_first, false)
 
       lc fun inlist List.wrap(funs) do
-        case Macro.extract_args(fun) do
+        case Macro.decompose_call(fun) do
           { name, args } -> :ok
-          :error -> raise ArgumentError, message: "invalid syntax in defdelegate #{Macro.to_string(fun)}"
+          _ -> raise ArgumentError, message: "invalid syntax in defdelegate #{Macro.to_string(fun)}"
         end
 
         actual_args =

lib/elixir/lib/kernel/special_forms.ex

@@ -34,7 +34,7 @@ defmodule Kernel.SpecialForms do
       { :{}, [], [1,2,3] }
 
   """
-  defmacro :{}.(args)
+  defmacro unquote(:{})(args)
 
   @doc """
   Defines a new bitstring.
@@ -171,7 +171,7 @@ defmodule Kernel.SpecialForms do
   For floats, unit * size must result in 32 or 64, corresponding
   to binary32 and binary64, respectively.
   """
-  defmacro :<<>>.(args)
+  defmacro unquote(:<<>>)(args)
 
   @doc """
   Defines a remote call or an alias.
@@ -284,7 +284,7 @@ defmodule Kernel.SpecialForms do
        [{:__aliases__, [alias: false], [:String]}, Sample]}
 
   """
-  defmacro (:.).(left, right)
+  defmacro unquote(:.)(left, right)
 
   @doc """
   `alias` is used to setup aliases, often useful with modules names.
@@ -943,8 +943,7 @@ defmodule Kernel.SpecialForms do
       #=> { :sum, [], [1, 13, 3] }
 
   """
-  name = :unquote
-  defmacro unquote(name)(expr)
+  defmacro unquote(:unquote)(expr)
 
   @doc """
   Unquotes the given list expanding its arguments. Similar
@@ -957,8 +956,7 @@ defmodule Kernel.SpecialForms do
       #=> { :sum, [], [1, 2, 3, 4, 5] }
 
   """
-  name = :unquote_splicing
-  defmacro unquote(name)(expr)
+  defmacro unquote(:unquote_splicing)(expr)
 
   @doc """
   List comprehensions allow you to quickly build a list from another list:
@@ -1042,8 +1040,7 @@ defmodule Kernel.SpecialForms do
       3
 
   """
-  name = :fn
-  defmacro unquote(name)(clauses)
+  defmacro unquote(:fn)(clauses)
 
   @doc """
   Internal special form for block expressions.
@@ -1133,8 +1130,7 @@ defmodule Kernel.SpecialForms do
       &(foo(&1, &2); &3 + &4)
 
   """
-  name = :&
-  defmacro unquote(name)(expr)
+  defmacro unquote(:&)(expr)
 
   @doc """
   Internal special form to hold aliases information.

lib/elixir/lib/macro.ex

@@ -81,52 +81,44 @@ defmodule Macro do
       message: "cannot pipe #{to_string expr} into #{to_string call_args}"
   end
 
-  @doc """
-  Receives an expression representing a possible definition
-  and extracts its arguments. It returns a tuple with the
-  function name and the arguments list or `:error` if not
-  a valid call syntax.
-
-  This is useful for macros that want to provide the same
-  argument syntax available in def/defp/defmacro and friends.
-
-  ## Examples
-
-      extract_args(quote do: foo)        == { :foo, [] }
-      extract_args(quote do: foo())      == { :foo, [] }
-      extract_args(quote do: foo(1, 2, 3)) == { :foo, [1, 2, 3] }
-      extract_args(quote do: 1.(1, 2, 3))  == :error
-
-  """
-  @spec extract_args(Macro.t) :: { atom, [Macro.t] } | :error
+  @doc false
   def extract_args(expr) do
-    :elixir_clauses.extract_args(expr)
+    IO.write "Macro.extract_args/1 is deprecated, use Macro.decompose_call/1 instead\n#{Exception.format_stacktrace}"
+    decompose_call(expr)
   end
 
   @doc """
-  Decomposes a local or remote call into its module alias (when a remote
-  call is provided), function name and argument list. 
-  Returns :error when an invalid call syntax is provied.
+  Decomposes a local or remote call into its remote part (when provided),
+  function name and argument list.
+
+  Returns `:error` when an invalid call syntax is provided.
 
   ## Examples
 
-      decompose_call(quote do: foo) == { :foo, [] }
-      decompose_call(quote do: foo()) == { :foo, [] }
-      decompose_call(quote do: foo(1, 2, 3)) == { :foo, [1, 2, 3] }
-      decompose_call(quote do: M.N.foo(1, 2, 3)) ==
-        { { :__aliases__, [alias: false], [:M, :N] }, :foo, [1, 2, 3] }
-      decompose_call(quote do: 42) == :error
+      iex> Macro.decompose_call(quote do: foo)
+      { :foo, [] }
+      iex> Macro.decompose_call(quote do: foo())
+      { :foo, [] }
+      iex> Macro.decompose_call(quote do: foo(1, 2, 3))
+      { :foo, [1, 2, 3] }
+      iex> Macro.decompose_call(quote do: M.N.foo(1, 2, 3))
+      { { :__aliases__, [alias: false], [:M, :N] }, :foo, [1, 2, 3] }
+      iex> Macro.decompose_call(quote do: 42)
+      :error
 
   """
   @spec decompose_call(Macro.t) :: { atom, [Macro.t] } | { Macro.t, atom, [Macro.t] } | :error
-  def decompose_call(expr) do
-    case expr do
-      { { :., _, [{ :__aliases__, meta, atoms }, f] }, _, args } ->
-        { { :__aliases__, meta, atoms }, f, args }
-      _local ->
-        :elixir_clauses.extract_args(expr)
-    end
-  end
+  def decompose_call({ { :., _, [remote, function] }, _, args }) when is_tuple(remote) or is_atom(remote),
+    do: { remote, function, args }
+
+  def decompose_call({ name, _, args }) when is_atom(name) and is_atom(args),
+    do: { name, [] }
+
+  def decompose_call({ name, _, args }) when is_atom(name) and is_list(args),
+    do: { name, args }
+
+  def decompose_call(_),
+    do: :error
 
   @doc """
   Recursively escapes a value so it can be inserted

lib/elixir/src/elixir_clauses.erl

@@ -3,7 +3,7 @@
 -module(elixir_clauses).
 -export([
   assigns/3, assigns_block/5, assigns_block/6, extract_splat_guards/1,
-  get_pairs/4, get_pairs/5, match/3, extract_args/1, extract_guards/1]).
+  get_pairs/4, get_pairs/5, match/3, extract_guards/1]).
 -include("elixir.hrl").
 
 %% Get pairs from a clause.
@@ -73,13 +73,6 @@ extract_guards(Else) -> { Else, [] }.
 extract_or_clauses({ 'when', _, [Left, Right] }) -> [Left|extract_or_clauses(Right)];
 extract_or_clauses(Term) -> [Term].
 
-% Extract name and args from the given expression.
-
-extract_args({ { '.', _, [Name] }, _, Args }) when is_atom(Name), is_list(Args) -> { Name, Args };
-extract_args({ Name, _, Args }) when is_atom(Name), is_atom(Args) -> { Name, [] };
-extract_args({ Name, _, Args }) when is_atom(Name), is_list(Args) -> { Name, Args };
-extract_args(_) -> error.
-
 % Extract guards when multiple left side args are allowed.
 
 extract_splat_guards([{ 'when', _, [_,_|_] = Args }]) ->

lib/elixir/src/elixir_def.erl

@@ -53,12 +53,12 @@ store_definition(Kind, CheckClauses, Call, Body, ExEnv) ->
   S = elixir_env:env_to_scope(Env),
   { NameAndArgs, Guards } = elixir_clauses:extract_guards(Call),
 
-  { Name, Args } = case elixir_clauses:extract_args(NameAndArgs) of
-    error ->
+  { Name, Args } = case NameAndArgs of
+    { N, _, A } when is_atom(N), is_atom(A) -> { N, [] };
+    { N, _, A } when is_atom(N), is_list(A) -> { N, A };
+    _ ->
       Format = [Kind, 'Elixir.Macro':to_string(NameAndArgs)],
-      elixir_errors:syntax_error(Line, S#elixir_scope.file, "invalid syntax in ~ts ~ts", Format);
-    Tuple ->
-      Tuple
+      elixir_errors:syntax_error(Line, S#elixir_scope.file, "invalid syntax in ~ts ~ts", Format)
   end,
 
   %% Now that we have verified the call format,

lib/elixir/test/elixir/macro_test.exs

@@ -396,25 +396,16 @@ defmodule MacroTest do
    assert Macro.safe_term(quote do: {1+1}) == { :unsafe, quote do: 1 + 1 }
   end
 
-  ## extract_args
-
-  test :extract_args do
-    assert Macro.extract_args(quote do: foo)        == { :foo, [] }
-    assert Macro.extract_args(quote do: foo())      == { :foo, [] }
-    assert Macro.extract_args(quote do: :foo.())    == { :foo, [] }
-    assert Macro.extract_args(quote do: foo(1, 2, 3)) == { :foo, [1, 2, 3] }
-    assert Macro.extract_args(quote do: 1.(1, 2, 3))  == :error
-  end
-
   ## decompose_call
 
   test :decompose_call do
     assert Macro.decompose_call(quote do: foo)        == { :foo, [] }
     assert Macro.decompose_call(quote do: foo())      == { :foo, [] }
-    assert Macro.decompose_call(quote do: :foo.())    == { :foo, [] }
     assert Macro.decompose_call(quote do: foo(1, 2, 3)) == { :foo, [1, 2, 3] }
     assert Macro.decompose_call(quote do: M.N.foo(1, 2, 3)) ==
            { { :__aliases__, [alias: false], [:M, :N] }, :foo, [1, 2, 3] }
+    assert Macro.decompose_call(quote do: :foo.foo(1, 2, 3)) ==
+           { :foo, :foo, [1, 2, 3] }
     assert Macro.decompose_call(quote do: 1.(1, 2, 3))  == :error
     assert Macro.decompose_call(quote do: "some string")  == :error
   end

lib/elixir/test/erlang/module_test.erl

@@ -24,13 +24,6 @@ function_test() ->
   end,
   test_helper:run_and_remove(F, ['Elixir.Foo.Bar.Baz']).
 
-dynamic_function_test() ->
-  F = fun() ->
-    eval("defmodule Foo.Bar.Baz do\ndef :sum.(a, b) do\na + b\nend\nend"),
-    3 = 'Elixir.Foo.Bar.Baz':sum(1, 2)
-  end,
-  test_helper:run_and_remove(F, ['Elixir.Foo.Bar.Baz']).
-
 quote_unquote_splicing_test() ->
   { { '{}', [], [1,2,3,4,5] }, _ } = eval("x = [2,3,4]\nquote do: { 1, unquote_splicing(x), 5}").