Support macros with defoverridable/super (#4848)

Author: whatyouhide

lib/elixir/src/elixir_def_overridable.erl

@@ -1,6 +1,6 @@
 % Holds the logic responsible for defining overridable functions and handling super.
 -module(elixir_def_overridable).
--export([setup/1, overridable/1, overridable/2, name/2, super/2, store_pending/1,
+-export([setup/1, overridable/1, overridable/2, kind_and_name/2, super/2, store_pending/1,
          ensure_defined/4, format_error/1]).
 -include("elixir.hrl").
 -define(attr, {elixir, overridable}).
@@ -23,15 +23,21 @@ ensure_defined(Meta, Module, Tuple, S) ->
     _ -> elixir_errors:form_error(Meta, S#elixir_scope.file, ?MODULE, {no_super, Module, Tuple})
   end.
 
-%% Gets the name based on the function and stored overridables
+%% Builds a function name based on how many times the function has been
+%% overridden.
 
-name(Module, Function) ->
-  name(Module, Function, overridable(Module)).
-
-name(_Module, {Name, _} = Function, Overridable) ->
-  {Count, _, _, _} = maps:get(Function, Overridable),
+name({Name, _} = _Function, Count) when is_integer(Count) ->
   elixir_utils:atom_concat([Name, " (overridable ", Count, ")"]).
 
+%% Returns the kind (def, defp, and so on) of the given overridable function and
+%% its overridable name.
+
+kind_and_name(Module, FunctionOrMacro) ->
+  Overridable = overridable(Module),
+  {Count, Clause, _, _} = maps:get(FunctionOrMacro, Overridable),
+  {{{def, _Function}, Kind, _Line, _File, _Check, _Location, _Defaults}, _Clauses} = Clause,
+  {Kind, name(FunctionOrMacro, Count)}.
+
 %% Store
 
 store(Module, Function, GenerateName) ->
@@ -44,10 +50,15 @@ store(Module, Function, GenerateName) ->
       {{{def, {Name, Arity}}, Kind, Line, File, _Check,
        Location, {Defaults, _HasBody, _LastDefaults}}, Clauses} = Clause,
 
-      {FinalKind, FinalName} = case GenerateName of
-        true  -> {defp, name(Module, Function, Overridable)};
-        false -> {Kind, Name}
-      end,
+      {FinalKind, FinalName, FinalArity} =
+        case {GenerateName, Kind} of
+          {false, _} ->
+            {Kind, Name, Arity};
+          {true, K} when K == defmacro; K == defmacrop ->
+            {defp, elixir_utils:macro_name(name(Function, Count)), Arity + 1};
+          {true, K} when K == def; K == defp ->
+            {defp, name(Function, Count), Arity}
+        end,
 
       case elixir_compiler:get_opt(internal) of
         false ->
@@ -56,7 +67,7 @@ store(Module, Function, GenerateName) ->
           ok
       end,
 
-      Def = {function, Line, FinalName, Arity, Clauses},
+      Def = {function, Line, FinalName, FinalArity, Clauses},
       elixir_def:store_each(false, FinalKind, File, Location, Module, Defaults, Def)
   end.
 

lib/elixir/src/elixir_translator.erl

@@ -161,8 +161,15 @@ translate({super, Meta, Args}, S) when is_list(Args) ->
                     "arguments as the current function")
   end,
 
-  Super = elixir_def_overridable:name(Module, Function),
-  {{call, ?ann(Meta), {atom, ?ann(Meta), Super}, TArgs}, TS#elixir_scope{super=true}};
+  {FinalName, FinalArgs} =
+    case elixir_def_overridable:kind_and_name(Module, Function) of
+      {Kind, Name} when Kind == def; Kind == defp ->
+        {Name, TArgs};
+      {Kind, Name} when Kind == defmacro; Kind == defmacrop ->
+        {elixir_utils:macro_name(Name), [{var, ?ann(Meta), '_@CALLER'} | TArgs]}
+    end,
+
+  {{call, ?ann(Meta), {atom, ?ann(Meta), FinalName}, FinalArgs}, TS#elixir_scope{super=true}};
 
 %% Variables
 

lib/elixir/test/elixir/kernel/overridable_test.exs

@@ -93,6 +93,18 @@ defmodule Kernel.Overridable do
   def many_clauses(x) do
     super(x)
   end
+
+  ## Macros
+
+  defmacro overridable_macro(x) do
+    x + 100
+  end
+
+  defoverridable overridable_macro: 1
+
+  defmacro overridable_macro(x) do
+    super(x) + 1_000
+  end
 end
 
 defmodule Kernel.OverridableTest do
@@ -170,4 +182,8 @@ defmodule Kernel.OverridableTest do
           "Overridable functions available are: bar/0"
     end
   end
+
+  test "overridable macros" do
+    assert Overridable.overridable_macro(1) == 1101
+  end
 end