Ensure defaults and defoverridable work together, closes #6300

This commit changes the private super implementation to have
a tuple with the {kind, name} as first argument.

Signed-off-by: José Valim <jose.valim@plataformatec.com.br>

Author: José Valim

lib/elixir/lib/exception.ex

@@ -230,7 +230,7 @@ defmodule Exception do
          {_, kind, _, clauses} <- List.keyfind(defs, {function, arity}, 0) do
       clauses =
         for {meta, ex_args, guards, _block} <- clauses do
-          scope = :elixir_erl.definition_scope(meta, kind, function, arity, "nofile")
+          scope = :elixir_erl.definition_scope(meta, kind, "nofile")
           {erl_args, scope} =
             :elixir_erl_clauses.match(&:elixir_erl_pass.translate_args/2, ex_args, scope)
           {args, binding} =
@@ -862,8 +862,7 @@ defmodule UndefinedFunctionError do
   end
 
   defp format_fa({_dist, fun, arity}) do
-    fun = with ":" <> fun <- inspect(fun), do: fun
-    ["      * ", fun, ?/, Integer.to_string(arity), ?\n]
+    ["      * ", Inspect.Function.escape_name(fun), ?/, Integer.to_string(arity), ?\n]
   end
 
   defp exports_for(module) do

lib/elixir/lib/module/locals_tracker.ex

@@ -166,8 +166,8 @@ defmodule Module.LocalsTracker do
   end
 
   defp unreachable(reachable, private) do
-    for {tuple, kind, _, _} <- private,
-        kind == :defmacrop or not :sets.is_element(tuple, reachable),
+    for {tuple, _, _, _} <- private,
+        not :sets.is_element(tuple, reachable),
         do: tuple
   end
 

lib/elixir/src/elixir.hrl

@@ -5,7 +5,7 @@
 -define(var_context, ?MODULE).
 
 -record(elixir_erl, {
-  def=nil,                 %% a tuple with the current definition {def | ..., name, arity}
+  def=nil,                 %% the definition kind (def, defp, etc)
   context=nil,             %% can be match, guards or nil
   extra=nil,               %% extra information about the context, like pin_guard and map_key
   caller=false,            %% when true, it means caller was invoked

lib/elixir/src/elixir_def.erl

@@ -22,7 +22,7 @@ local_for(Module, Name, Arity, Kinds) ->
   of
     {[{_, Kind, Meta, File, _, _}], Clauses} ->
       case (Kinds == all) orelse (lists:member(Kind, Kinds)) of
-        true -> elixir_erl:definition_to_anonymous(File, Module, Tuple, Kind, Meta,
+        true -> elixir_erl:definition_to_anonymous(File, Module, Kind, Meta,
                                                    [Clause || {_, Clause} <- Clauses]);
         false -> false
       end;
@@ -212,7 +212,7 @@ unpack_defaults(Kind, Meta, Name, Args, E) ->
 unpack_defaults(Kind, Meta, Name, [{'\\\\', DefaultMeta, [Expr, _]} | T] = List, Acc, Clauses) ->
   Base = match_defaults(Acc, length(Acc), []),
   {Args, Invoke} = extract_defaults(List, length(Base), [], []),
-  Clause = {Meta, Base ++ Args, [], {super, DefaultMeta, Base ++ Invoke}},
+  Clause = {Meta, Base ++ Args, [], {super, DefaultMeta, [{Kind, Name} | Base] ++ Invoke}},
   unpack_defaults(Kind, Meta, Name, T, [Expr | Acc], [Clause | Clauses]);
 unpack_defaults(Kind, Meta, Name, [H | T], Acc, Clauses) ->
   unpack_defaults(Kind, Meta, Name, T, [H | Acc], Clauses);

lib/elixir/src/elixir_env.erl

@@ -22,7 +22,9 @@ new() ->
     prematch_vars => nil}.                 %% a set of variables defined before the current match
 
 linify({Line, Env}) ->
-  Env#{line := Line}.
+  Env#{line := Line};
+linify(#{} = Env) ->
+  Env.
 
 env_to_scope(#{file := File, context := Context}) ->
   #elixir_erl{file=File, context=Context}.

lib/elixir/src/elixir_erl.erl

@@ -1,8 +1,8 @@
 %% Compiler backend to Erlang.
 -module(elixir_erl).
--export([elixir_to_erl/1, definition_to_anonymous/6, compile/1,
+-export([elixir_to_erl/1, definition_to_anonymous/5, compile/1,
          get_ann/1, remote/4, add_beam_chunks/2, debug_info/4,
-         definition_scope/5]).
+         definition_scope/3]).
 -include("elixir.hrl").
 
 %% TODO: Remove extra chunk functionality when OTP 20+.
@@ -61,8 +61,8 @@ remote(Ann, Module, Function, Args) when is_atom(Module), is_atom(Function), is_
 
 %% Converts an Elixir definition to an anonymous function.
 
-definition_to_anonymous(File, Module, {Name, Arity}, Kind, Meta, Clauses) ->
-  ErlClauses = [translate_clause(Kind, Name, Arity, Clause, File) || Clause <- Clauses],
+definition_to_anonymous(File, Module, Kind, Meta, Clauses) ->
+  ErlClauses = [translate_clause(Kind, Clause, File) || Clause <- Clauses],
   Fun = {'fun', ?ann(Meta), {clauses, ErlClauses}},
   LocalHandler = fun(LocalName, LocalArgs) -> invoke_local(Module, LocalName, LocalArgs) end,
   {value, Result, _Binding} = erl_eval:expr(Fun, [], {value, LocalHandler}),
@@ -137,14 +137,14 @@ elixir_to_erl_cons2([], Acc) ->
 
 %% Returns a definition scope for translation.
 
-definition_scope(Meta, Kind, Name, Arity, File) ->
+definition_scope(Meta, Kind, File) ->
   %% TODO: We only need to do this dance because some
   %% warnings are raised in elixir_erl_pass. Once we remove
   %% all warnings from the Erlang pass, we can remove the
   %% file field from #elixir_erl and clean up the code.
   case lists:keyfind(location, 1, Meta) of
-    {location, {F, _}} -> #elixir_erl{def = {Kind, Name, Arity}, file = F};
-    false -> #elixir_erl{def = {Kind, Name, Arity}, file = File}
+    {location, {F, _}} -> #elixir_erl{def=Kind,file=F};
+    false -> #elixir_erl{def=Kind,file=File}
   end.
 
 %% Compilation hook.
@@ -167,9 +167,15 @@ split_definition([{Tuple, def, Meta, Clauses} | T], File, Unreachable,
   split_definition(T, File, Unreachable, [Tuple | Def], Defmacro, [{N, A} | Exports],
                    add_definition(Meta, Function, Functions));
 
-split_definition([{Tuple, defp, Meta, Clauses} | T], File, Unreachable,
+split_definition([{Tuple, defmacro, Meta, Clauses} | T], File, Unreachable,
                  Def, Defmacro, Exports, Functions) ->
-  Function = translate_definition(defp, Meta, File, Tuple, Clauses),
+  {_, _, N, A, _} = Function = translate_definition(defmacro, Meta, File, Tuple, Clauses),
+  split_definition(T, File, Unreachable, Def, [Tuple | Defmacro], [{N, A} | Exports],
+                   add_definition(Meta, Function, Functions));
+
+split_definition([{Tuple, Kind, Meta, Clauses} | T], File, Unreachable,
+                 Def, Defmacro, Exports, Functions) ->
+  Function = translate_definition(Kind, Meta, File, Tuple, Clauses),
   case lists:member(Tuple, Unreachable) of
     false ->
       split_definition(T, File, Unreachable, Def, Defmacro, Exports,
@@ -178,16 +184,6 @@ split_definition([{Tuple, defp, Meta, Clauses} | T], File, Unreachable,
       split_definition(T, File, Unreachable, Def, Defmacro, Exports, Functions)
   end;
 
-split_definition([{Tuple, defmacro, Meta, Clauses} | T], File, Unreachable,
-                 Def, Defmacro, Exports, Functions) ->
-  {_, _, N, A, _} = Function = translate_definition(defmacro, Meta, File, Tuple, Clauses),
-  split_definition(T, File, Unreachable, Def, [Tuple | Defmacro], [{N, A} | Exports],
-                   add_definition(Meta, Function, Functions));
-
-split_definition([{_, defmacrop, _Meta, _Clauses} | T], File, Unreachable,
-                 Def, Defmacro, Exports, Functions) ->
-  split_definition(T, File, Unreachable, Def, Defmacro, Exports, Functions);
-
 split_definition([], _File, _Unreachable, Def, Defmacro, Exports, {Head, Tail}) ->
   {Def, Defmacro, Exports, Head ++ Tail}.
 
@@ -206,15 +202,15 @@ add_definition(Meta, Body, {Head, Tail}) ->
   end.
 
 translate_definition(Kind, Meta, File, {Name, Arity}, Clauses) ->
-  ErlClauses = [translate_clause(Kind, Name, Arity, Clause, File) || Clause <- Clauses],
+  ErlClauses = [translate_clause(Kind, Clause, File) || Clause <- Clauses],
 
   case is_macro(Kind) of
     true -> {function, ?ann(Meta), elixir_utils:macro_name(Name), Arity + 1, ErlClauses};
     false -> {function, ?ann(Meta), Name, Arity, ErlClauses}
   end.
 
-translate_clause(Kind, Name, Arity, {Meta, Args, Guards, Body}, File) ->
-  S = definition_scope(Meta, Kind, Name, Arity, File),
+translate_clause(Kind, {Meta, Args, Guards, Body}, File) ->
+  S = definition_scope(Meta, Kind, File),
 
   {TClause, TS} = elixir_erl_clauses:clause(Meta,
                     fun elixir_erl_pass:translate_args/2, Args, Body, Guards, S),

lib/elixir/src/elixir_erl_pass.erl

@@ -38,18 +38,24 @@ translate({'__block__', Meta, Args}, S) when is_list(Args) ->
 
 %% Compilation environment macros
 
-translate({'__CALLER__', Meta, Atom}, S) when is_atom(Atom) ->
-  {{var, ?ann(Meta), '__CALLER__'}, S#elixir_erl{caller=true}};
+translate({'__CALLER__', Meta, Atom}, #elixir_erl{def=Kind}=S) when is_atom(Atom) ->
+  if
+    Kind == defmacro; Kind == defmacrop ->
+      {{var, ?ann(Meta), '__CALLER__'}, S#elixir_erl{caller=true}};
+    true ->
+      {{atom, ?ann(Meta), nil}, S}
+  end;
 
-translate({'super', Meta, Args}, #elixir_erl{def={Kind, Name, _}} = S) ->
+translate({'super', Meta, [{Kind,Name}|Args]}, S) ->
   %% In the expanded AST, super is used to invoke a function
-  %% with the same name but possibly different arity.
+  %% in the current module originated from a default clause
+  %% or a super call.
   {TArgs, SA} = translate_args(Args, S),
   Ann = ?ann(Meta),
   if
     Kind == defmacro; Kind == defmacrop ->
       MacroName = elixir_utils:macro_name(Name),
-      {{call, Ann, {atom, Ann, MacroName}, [{var, Ann, '_@CALLER'} | TArgs]}, SA};
+      {{call, Ann, {atom, Ann, MacroName}, [{var, Ann, '__CALLER__'} | TArgs]}, SA#elixir_erl{caller=true}};
     Kind == def; Kind == defp ->
       {{call, Ann, {atom, Ann, Name}, TArgs}, SA}
   end;

lib/elixir/src/elixir_expand.erl

@@ -296,14 +296,9 @@ expand({super, Meta, Args}, #{file := File} = E) when is_list(Args) ->
 
   case length(Args) of
     Arity ->
-      {OName, OArity} = elixir_overridable:super(Meta, File, Module, Function),
+      {Kind, Name} = elixir_overridable:super(Meta, File, Module, Function),
       {EArgs, EA} = expand_args(Args, E),
-      OArgs =
-        if
-          OArity > Arity -> [{'__CALLER__', [], nil} | EArgs];
-          true -> EArgs
-        end,
-      {{OName, Meta, OArgs}, EA};
+      {{super, Meta, [{Kind, Name} | EArgs]}, EA};
     _ ->
       form_error(Meta, File, ?MODULE, wrong_number_of_args_for_super)
   end;

lib/elixir/src/elixir_overridable.erl

@@ -15,15 +15,15 @@ overridable(Module, Value) ->
 
 super(Meta, File, Module, Function) ->
   case store(Module, Function, true) of
-    {ok, Name} ->
-      Name;
+    {_, _} = KindName ->
+      KindName;
     error ->
       elixir_errors:form_error(Meta, File, ?MODULE, {no_super, Module, Function})
   end.
 
 store_pending(Module) ->
   [begin
-    {ok, _} = store(Module, Pair, false),
+    {_, _} = store(Module, Pair, false),
     Pair
    end || {Pair, {_, _, _, false}} <- maps:to_list(overridable(Module)),
           not 'Elixir.Module':'defines?'(Module, Pair)].
@@ -42,7 +42,7 @@ store(Module, Function, Hidden) ->
           false ->
             {Kind, Name, Arity, Clauses};
           true when Kind == defmacro; Kind == defmacrop ->
-            {defp, name(Name, Count), Arity + 1, rewrite_clauses(Clauses)};
+            {defmacrop, name(Name, Count), Arity, Clauses};
           true ->
             {defp, name(Name, Count), Arity, Clauses}
         end,
@@ -62,15 +62,11 @@ store(Module, Function, Hidden) ->
           ok
       end,
 
-      {ok, Tuple};
+      {FinalKind, FinalName};
     error ->
       error
   end.
 
-rewrite_clauses(Clauses) ->
-  [{Meta, [{'__CALLER__', [], nil} | Args], Guards, Body} ||
-   {Meta, Args, Guards, Body} <- Clauses].
-
 name(Name, Count) when is_integer(Count) ->
   list_to_atom(atom_to_list(Name) ++ " (overridable " ++ integer_to_list(Count) ++ ")").
 
@@ -83,6 +79,6 @@ format_error({no_super, Module, {Name, Arity}}) ->
     [Name, Arity, elixir_aliases:inspect(Module), Joined]).
 
 format_fa({Name, Arity}) ->
-  A = atom_to_binary(Name, utf8),
+  A = 'Elixir.Inspect.Function':escape_name(Name),
   B = integer_to_binary(Arity),
   <<A/binary, $/, B/binary>>.

lib/elixir/test/elixir/kernel/expansion_test.exs

@@ -170,6 +170,7 @@ defmodule Kernel.ExpansionTest do
     end
 
     test "__CALLER__" do
+      assert __CALLER__ == nil
       assert expand(quote do: __CALLER__) == quote do: __CALLER__
     end