Do not serialize references, closes #6393

Author: José Valim

lib/elixir/lib/kernel.ex

@@ -3565,7 +3565,6 @@ defmodule Kernel do
   defp define(kind, call, expr, env) do
     module = assert_module_scope(env, kind, 2)
     assert_no_function_scope(env, kind, 2)
-    table = :elixir_module.data_table(module)
 
     {escaped_call, unquoted_call} = :elixir_quote.escape(call, true)
     {escaped_expr, unquoted_expr} = :elixir_quote.escape(expr, true)
@@ -3575,14 +3574,14 @@ defmodule Kernel do
         true ->
           escaped_expr
         false ->
-          key = {:cache_def, :erlang.unique_integer()}
-          :ets.insert(table, {key, expr})
-          quote do: :ets.lookup_element(unquote(table), unquote(key), 2)
+          key = :erlang.unique_integer()
+          :elixir_module.write_cache(module, key, expr)
+          quote do: :elixir_module.read_cache(unquote(module), unquote(key))
       end
 
     # Do not check clauses if any expression was unquoted
     check_clauses = not(unquoted_expr or unquoted_call)
-    pos = :elixir_locals.cache_env(table, env)
+    pos = :elixir_locals.cache_env(env)
 
     quote do
       :elixir_def.store_definition(unquote(kind), unquote(check_clauses),

lib/elixir/src/elixir_erl.erl

@@ -121,9 +121,9 @@ elixir_to_erl(Function) when is_function(Function) ->
     false ->
       error(badarg)
   end;
-elixir_to_erl(PidOrRef) when is_pid(PidOrRef); is_reference(PidOrRef) ->
+elixir_to_erl(Pid) when is_pid(Pid) ->
   elixir_erl:remote(0, erlang, binary_to_term,
-    [elixir_erl:elixir_to_erl(term_to_binary(PidOrRef))]);
+    [elixir_erl:elixir_to_erl(term_to_binary(Pid))]);
 elixir_to_erl(_Other) ->
   error(badarg).
 

lib/elixir/src/elixir_expand.erl

@@ -448,15 +448,15 @@ expand(Function, E) when is_function(Function) ->
   end;
 
 
-expand(PidOrRef, E) when is_pid(PidOrRef); is_reference(PidOrRef) ->
+expand(Pid, E) when is_pid(Pid) ->
   case ?key(E, function) of
     nil ->
-      {PidOrRef, E};
+      {Pid, E};
     Function ->
       %% TODO: Make me an error on 2.0
       elixir_errors:form_warn([], ?key(E, file), ?MODULE,
-                              {invalid_pid_or_ref_in_function, PidOrRef, Function}),
-      {PidOrRef, E}
+                              {invalid_pid_in_function, Pid, Function}),
+      {Pid, E}
   end;
 
 expand(Other, E) when is_number(Other); is_atom(Other); is_binary(Other) ->
@@ -949,9 +949,9 @@ format_error({invalid_local_invocation, Context, {Name, _, Args} = Call}) ->
 format_error({invalid_remote_invocation, Context, Receiver, Right, Arity}) ->
   io_lib:format("cannot invoke remote function ~ts.~ts/~B inside ~ts",
                 ['Elixir.Macro':to_string(Receiver), Right, Arity, Context]);
-format_error({invalid_pid_or_ref_in_function, PidOrRef, {Name, Arity}}) ->
-  io_lib:format("cannot compile PID/Reference ~ts inside quoted expression for function ~ts/~B",
-                ['Elixir.Kernel':inspect(PidOrRef, []), Name, Arity]);
+format_error({invalid_pid_in_function, Pid, {Name, Arity}}) ->
+  io_lib:format("cannot compile PID ~ts inside quoted expression for function ~ts/~B",
+                ['Elixir.Kernel':inspect(Pid, []), Name, Arity]);
 format_error({unsupported_option, Kind, Key}) ->
   io_lib:format("unsupported option ~ts given to ~s",
                 ['Elixir.Macro':to_string(Key), Kind]);

lib/elixir/src/elixir_locals.erl

@@ -1,7 +1,7 @@
 %% Module responsible for tracking invocations of module calls.
 -module(elixir_locals).
 -export([
-  setup/1, cleanup/1, cache_env/1, cache_env/2, get_cached_env/1,
+  setup/1, cleanup/1, cache_env/1, get_cached_env/1,
   record_local/2, record_local/3, record_import/4,
   record_definition/3, record_defaults/4, reattach/5,
   ensure_no_import_conflict/3, warn_unused_local/3, format_error/1
@@ -60,10 +60,8 @@ if_tracker(Module, Default, Callback) ->
 
 %% CACHING
 
-cache_env(#{module := Module} = E) ->
-  cache_env(elixir_module:data_table(Module), E).
-
-cache_env(Table, #{line := Line} = E) ->
+cache_env(#{line := Line, module := Module} = E) ->
+  Table = elixir_module:data_table(Module),
   Cache = E#{line := nil, vars := []},
 
   Pos =
@@ -77,10 +75,10 @@ cache_env(Table, #{line := Line} = E) ->
         Key
     end,
 
-  {Table, {Line, Pos}}.
+  {Module, {Line, Pos}}.
 
-get_cached_env({Table, {Line, Pos}}) ->
-  (ets:lookup_element(Table, {cache_env, Pos}, 2))#{line := Line};
+get_cached_env({Module, {Line, Pos}}) ->
+  (ets:lookup_element(elixir_module:data_table(Module), {cache_env, Pos}, 2))#{line := Line};
 get_cached_env(Env) ->
   Env.
 

lib/elixir/src/elixir_module.erl

@@ -1,7 +1,8 @@
 -module(elixir_module).
 -export([data_table/1, defs_table/1, is_open/1, delete_doc/6,
          compile/4, expand_callback/6, format_error/1,
-         compiler_modules/0, delete_impl/6]).
+         compiler_modules/0, delete_impl/6,
+         write_cache/3, read_cache/2]).
 -include("elixir.hrl").
 
 -define(lexical_attr, {elixir, lexical_tracker}).
@@ -39,6 +40,12 @@ delete_impl(#{module := Module}, _, _, _, _, _) ->
   ets:delete(data_table(Module), impl),
   ok.
 
+write_cache(Module, Key, Value) ->
+  ets:insert(data_table(Module), {{cache, Key}, Value}).
+
+read_cache(Module, Key) ->
+  ets:lookup_element(data_table(Module), {cache, Key}, 2).
+
 %% Compilation hook
 
 compile(Module, Block, Vars, #{line := Line} = Env) when is_atom(Module) ->