Add prune_binding to Code.eval_quoted_with_env/4

Author: josevalim

lib/elixir/lib/code.ex

@@ -181,7 +181,7 @@ defmodule Code do
   """
 
   @typedoc """
-  A list with all variable bindings.
+  A list with all variables and their values.
 
   The binding keys are usually atoms, but they may be a tuple for variables
   defined in a different context.
@@ -344,7 +344,7 @@ defmodule Code do
   @doc """
   Evaluates the contents given by `string`.
 
-  The `binding` argument is a list of variable bindings.
+  The `binding` argument is a list of all variables and their values.
   The `opts` argument is a keyword list of environment options.
 
   **Warning**: `string` can be any Elixir code and will be executed with
@@ -362,17 +362,15 @@ defmodule Code do
     * `:line` - the line on which the script starts
 
   Additionally, you may also pass an environment as second argument,
-  so the evaluation happens within that environment. However, if the evaluated
-  code requires or compiles another file, the environment given to this function
-  will not apply to said files.
+  so the evaluation happens within that environment.
 
   Returns a tuple of the form `{value, binding}`, where `value` is the value
   returned from evaluating `string`. If an error occurs while evaluating
-  `string` an exception will be raised.
+  `string`, an exception will be raised.
 
-  `binding` is a list with all variable bindings after evaluating `string`.
-  The binding keys are usually atoms, but they may be a tuple for variables
-  defined in a different context.
+  `binding` is a list with all variable names and their values after evaluating
+  `string`. The binding keys are usually atoms, but they may be a tuple for variables
+  defined in a different context. The names are in no particular order.
 
   ## Examples
 
@@ -419,13 +417,13 @@ defmodule Code do
   defp validated_eval_string(string, binding, opts_or_env) do
     %{line: line, file: file} = env = env_for_eval(opts_or_env)
     forms = :elixir.string_to_quoted!(to_charlist(string), line, 1, file, [])
-    {value, binding, _env} = eval_verify(:eval_forms, forms, binding, env)
+    {value, binding, _env} = eval_verify(:eval_forms, [forms, binding, env])
     {value, binding}
   end
 
-  defp eval_verify(fun, forms, binding, env) do
+  defp eval_verify(fun, args) do
     Module.ParallelChecker.verify(fn ->
-      apply(:elixir, fun, [forms, binding, env])
+      apply(:elixir, fun, args)
     end)
   end
 
@@ -822,7 +820,9 @@ defmodule Code do
   """
   @spec eval_quoted(Macro.t(), binding, Macro.Env.t() | keyword) :: {term, binding}
   def eval_quoted(quoted, binding \\ [], env_or_opts \\ []) do
-    {value, binding, _env} = eval_verify(:eval_quoted, quoted, binding, env_for_eval(env_or_opts))
+    {value, binding, _env} =
+      eval_verify(:eval_quoted, [quoted, binding, env_for_eval(env_or_opts)])
+
     {value, binding}
   end
 
@@ -859,10 +859,17 @@ defmodule Code do
   Therefore, the first time you call this function, you must compute
   the initial environment with `env_for_eval/1`. The remaining calls
   must pass the environment that was returned by this function.
+
+  ## Options
+
+    * `:prune_binding` - (since v1.14.2) prune binding to keep only
+      variables read or written by the evaluated code
+
   """
   @doc since: "1.14.0"
-  def eval_quoted_with_env(quoted, binding, %Macro.Env{} = env) when is_list(binding) do
-    eval_verify(:eval_forms, quoted, binding, env)
+  def eval_quoted_with_env(quoted, binding, %Macro.Env{} = env, opts \\ [])
+      when is_list(binding) do
+    eval_verify(:eval_quoted, [quoted, binding, env, opts])
   end
 
   @doc ~S"""

lib/elixir/src/elixir.erl

@@ -4,7 +4,8 @@
 -behaviour(application).
 -export([start_cli/0,
   string_to_tokens/5, tokens_to_quoted/3, 'string_to_quoted!'/5,
-  env_for_eval/1, quoted_to_erl/2, eval_forms/3, eval_quoted/3]).
+  env_for_eval/1, quoted_to_erl/2, eval_forms/3, eval_quoted/3,
+  eval_quoted/4]).
 -include("elixir.hrl").
 -define(system, 'Elixir.System').
 
@@ -260,18 +261,20 @@ env_for_eval(Opts) when is_list(Opts) ->
 
 %% Quoted evaluation
 
-eval_quoted(Tree, Binding, Opts) when is_list(Opts) ->
-  eval_quoted(Tree, Binding, env_for_eval(Opts));
-eval_quoted(Tree, Binding, #{line := Line} = E) ->
-  eval_forms(elixir_quote:linify(Line, line, Tree), Binding, E).
+eval_quoted(Tree, Binding, E) ->
+  eval_quoted(Tree, Binding, E, []).
+eval_quoted(Tree, Binding, #{line := Line} = E, Opts) ->
+  eval_forms(elixir_quote:linify(Line, line, Tree), Binding, E, Opts).
 
-eval_forms(Tree, Binding, Opts) when is_list(Opts) ->
-  eval_forms(Tree, Binding, env_for_eval(Opts));
 eval_forms(Tree, Binding, OrigE) ->
+  eval_forms(Tree, Binding, OrigE, []).
+eval_forms(Tree, Binding, OrigE, Opts) ->
+  Prune = proplists:get_value(prune_binding, Opts, false),
   {ExVars, ErlVars, ErlBinding} = elixir_erl_var:load_binding(Binding),
   E = elixir_env:with_vars(OrigE, ExVars),
-  S = elixir_erl_var:from_env(E, ErlVars),
-  {Erl, NewErlS, NewExS, NewE} = quoted_to_erl(Tree, E, S),
+  ExS = elixir_env:env_to_ex(E, Prune),
+  ErlS = elixir_erl_var:from_env(E, ErlVars),
+  {Erl, NewErlS, NewExS, NewE} = quoted_to_erl(Tree, ErlS, ExS, E),
 
   case Erl of
     {atom, _, Atom} ->
@@ -286,7 +289,8 @@ eval_forms(Tree, Binding, OrigE) ->
 
       ExternalHandler = eval_external_handler(NewE),
       {value, Value, NewBinding} = erl_eval:exprs(Exprs, ErlBinding, none, ExternalHandler),
-      {Value, elixir_erl_var:dump_binding(NewBinding, NewExS, NewErlS), NewE}
+      PruneBefore = if Prune -> length(Binding); true -> 0 end,
+      {Value, elixir_erl_var:dump_binding(NewBinding, NewErlS, NewExS, PruneBefore), NewE}
   end.
 
 %% TODO: Remove conditional once we require Erlang/OTP 25+.
@@ -356,13 +360,14 @@ eval_external_handler(_Env) ->
 %% Converts a quoted expression to Erlang abstract format
 
 quoted_to_erl(Quoted, E) ->
-  {_, S} = elixir_erl_var:from_env(E),
-  quoted_to_erl(Quoted, E, S).
+  {_, ErlS} = elixir_erl_var:from_env(E),
+  ExS = elixir_env:env_to_ex(E),
+  quoted_to_erl(Quoted, ErlS, ExS, E).
 
-quoted_to_erl(Quoted, Env, Scope) ->
+quoted_to_erl(Quoted, ErlS, ExS, Env) ->
   {Expanded, #elixir_ex{vars={ReadVars, _}} = NewExS, NewEnv} =
-    elixir_expand:expand(Quoted, elixir_env:env_to_ex(Env), Env),
-  {Erl, NewErlS} = elixir_erl_pass:translate(Expanded, erl_anno:new(?key(Env, line)), Scope),
+    elixir_expand:expand(Quoted, ExS, Env),
+  {Erl, NewErlS} = elixir_erl_pass:translate(Expanded, erl_anno:new(?key(Env, line)), ErlS),
   {Erl, NewErlS, NewExS, NewEnv#{versioned_vars := ReadVars}}.
 
 %% Converts a given string (charlist) into quote expression

lib/elixir/src/elixir_env.erl

@@ -1,7 +1,7 @@
 -module(elixir_env).
 -include("elixir.hrl").
 -export([
-  new/0, to_caller/1, with_vars/2, reset_vars/1, env_to_ex/1,
+  new/0, to_caller/1, with_vars/2, reset_vars/1, env_to_ex/1, env_to_ex/2,
   reset_unused_vars/1, check_unused_vars/2, merge_and_check_unused_vars/3,
   trace/2, format_error/1,
   reset_read/2, prepare_write/1, close_write/2
@@ -47,11 +47,19 @@ reset_vars(Env) ->
 
 %% CONVERSIONS
 
-env_to_ex(#{context := match, versioned_vars := Vars}) ->
+env_to_ex(Env) ->
+  env_to_ex(Env, false).
+
+env_to_ex(#{context := match, versioned_vars := Vars}, Prune) ->
   Counter = map_size(Vars),
-  #elixir_ex{prematch={Vars, Counter}, vars={Vars, false}, unused={#{}, Counter}};
-env_to_ex(#{versioned_vars := Vars}) ->
-  #elixir_ex{vars={Vars, false}, unused={#{}, map_size(Vars)}}.
+  Unused = unused(Vars, Prune),
+  #elixir_ex{prematch={Vars, Counter}, vars={Vars, false}, unused={Unused, Counter}};
+env_to_ex(#{versioned_vars := Vars}, Prune) ->
+  Unused = unused(Vars, Prune),
+  #elixir_ex{vars={Vars, false}, unused={Unused, map_size(Vars)}}.
+
+unused(_Vars, false) -> #{};
+unused(Vars, true) -> maps:from_list([{K, {0, false}} || K <- maps:to_list(Vars)]).
 
 %% VAR HANDLING
 
@@ -83,7 +91,7 @@ reset_unused_vars(#elixir_ex{unused={_Unused, Version}} = S) ->
 
 check_unused_vars(#elixir_ex{unused={Unused, _Version}}, E) ->
   [elixir_errors:form_warn([{line, Line}], E, ?MODULE, {unused_var, Name, Overridden}) ||
-    {{Name, _}, {Line, Overridden}} <- maps:to_list(Unused), is_unused_var(Name)],
+    {{{Name, nil}, _}, {Line, Overridden}} <- maps:to_list(Unused), is_unused_var(Name)],
   E.
 
 merge_and_check_unused_vars(S, #elixir_ex{vars={Read, Write}, unused={Unused, _Version}}, E) ->
@@ -93,20 +101,18 @@ merge_and_check_unused_vars(S, #elixir_ex{vars={Read, Write}, unused={Unused, _V
 
 merge_and_check_unused_vars(Current, Unused, ClauseUnused, E) ->
   maps:fold(fun
-    ({Name, Count} = Key, false, Acc) ->
-      Var = {Name, nil},
-
-      %% The parent knows it, so we have to propagate it was used up.
+    ({Var, Count} = Key, false, Acc) ->
       case Current of
         #{Var := CurrentCount} when Count =< CurrentCount ->
+          %% The parent knows it, so we have to propagate it was used up.
           Acc#{Key => false};
 
         #{} ->
           Acc
       end;
 
-    ({Name, _Count}, {Line, Overridden}, Acc) ->
-      case is_unused_var(Name) of
+    ({{Name, Kind}, _Count}, {Line, Overridden}, Acc) ->
+      case (Kind == nil) andalso is_unused_var(Name) of
         true ->
           Warn = {unused_var, Name, Overridden},
           elixir_errors:form_warn([{line, Line}], E, ?MODULE, Warn);

lib/elixir/src/elixir_erl_var.erl

@@ -2,7 +2,7 @@
 -module(elixir_erl_var).
 -export([
   translate/4, assign/2, build/2,
-  load_binding/1, dump_binding/3,
+  load_binding/1, dump_binding/4,
   from_env/1, from_env/2
 ]).
 -include("elixir.hrl").
@@ -101,9 +101,16 @@ load_binding([], ExVars, ErlVars, Normalized, _Counter) ->
 load_pair({Key, Value}) when is_atom(Key) -> {{Key, nil}, Value};
 load_pair({Pair, Value}) -> {Pair, Value}.
 
-dump_binding(Binding, #elixir_ex{vars={ExVars, _}}, #elixir_erl{var_names=ErlVars}) ->
+dump_binding(Binding, ErlS, ExS, PruneBefore) ->
+  #elixir_erl{var_names=ErlVars} = ErlS,
+  #elixir_ex{vars={ExVars, _}, unused={Unused, _}} = ExS,
+
   maps:fold(fun
-    ({Var, Kind} = Pair, Version, Acc) when is_atom(Kind) ->
+    ({Var, Kind} = Pair, Version, Acc)
+    % The variable has to have an atom context
+    % and it must be versioned after the original
+    % binding or be a used part of the original binding
+    when is_atom(Kind), (Version >= PruneBefore orelse map_get({Pair, Version}, Unused) == false) ->
       Key = case Kind of
         nil -> Var;
         _ -> Pair

lib/elixir/src/elixir_expand.erl

@@ -607,16 +607,16 @@ mapfold(_Fun, S, E, [], Acc) ->
 
 %% Match/var helpers
 
-var_unused({Name, Kind}, Meta, Version, Unused, Override) ->
+var_unused({_, Kind} = Pair, Meta, Version, Unused, Override) ->
   case (Kind == nil) andalso should_warn(Meta) of
-    true -> Unused#{{Name, Version} => {?line(Meta), Override}};
+    true -> Unused#{{Pair, Version} => {?line(Meta), Override}};
     false -> Unused
   end.
 
-var_used({Name, Kind}, Version, Unused) ->
-  case Kind of
-    nil -> Unused#{{Name, Version} => false};
-    _ -> Unused
+var_used({_, Kind} = Pair, Version, Unused) ->
+  if
+    is_atom(Kind) -> Unused#{{Pair, Version} => false};
+    true -> Unused
   end.
 
 maybe_warn_underscored_var_repeat(Meta, Name, Kind, E) ->

lib/elixir/test/elixir/code_test.exs

@@ -177,6 +177,35 @@ defmodule CodeTest do
     assert Macro.Env.vars(env) == [{:x, nil}]
   end
 
+  test "eval_quoted_with_env/3 with pruning" do
+    env = Code.env_for_eval(__ENV__)
+
+    fun = fn quoted, binding ->
+      {_, binding, _} = Code.eval_quoted_with_env(quoted, binding, env, prune_binding: true)
+      binding
+    end
+
+    assert fun.(quote(do: 123), []) == []
+    assert fun.(quote(do: 123), x: 2, y: 3) == []
+
+    assert fun.(quote(do: var!(x) = 1), []) == [x: 1]
+    assert fun.(quote(do: var!(x) = 1), x: 2, y: 3) == [x: 1]
+
+    assert fun.(quote(do: var!(x, :foo) = 1), []) == [{{:x, :foo}, 1}]
+    assert fun.(quote(do: var!(x, :foo) = 1), x: 2, y: 3) == [{{:x, :foo}, 1}]
+
+    assert fun.(quote(do: var!(x, :foo) = 1), [{{:x, :foo}, 2}, {{:y, :foo}, 3}]) ==
+             [{{:x, :foo}, 1}]
+
+    assert fun.(quote(do: fn -> var!(x, :foo) = 1 end), []) == []
+    assert fun.(quote(do: fn -> var!(x, :foo) = 1 end), x: 1, y: 2) == []
+
+    assert fun.(quote(do: fn -> var!(x) end), x: 2, y: 3) == [x: 2]
+
+    assert fun.(quote(do: fn -> var!(x, :foo) end), [{{:x, :foo}, 2}, {{:y, :foo}, 3}]) ==
+             [{{:x, :foo}, 2}]
+  end
+
   test "compile_file/1" do
     assert Code.compile_file(fixture_path("code_sample.exs")) == []
     refute fixture_path("code_sample.exs") in Code.required_files()

lib/elixir/test/erlang/atom_test.erl

@@ -3,8 +3,8 @@
 -include_lib("eunit/include/eunit.hrl").
 
 eval(Content) ->
-  {Value, Binding, _} =
-    elixir:eval_forms(elixir:'string_to_quoted!'(Content, 1, 1, <<"nofile">>, []), [], []),
+  Quoted = elixir:'string_to_quoted!'(Content, 1, 1, <<"nofile">>, []),
+  {Value, Binding, _} = elixir:eval_forms(Quoted, [], elixir:env_for_eval([])),
   {Value, Binding}.
 
 kv([{Key, nil}]) -> Key.

lib/elixir/test/erlang/function_test.erl

@@ -2,8 +2,8 @@
 -include_lib("eunit/include/eunit.hrl").
 
 eval(Content) ->
-  {Value, Binding, _} =
-    elixir:eval_forms(elixir:'string_to_quoted!'(Content, 1, 1, <<"nofile">>, []), [], []),
+  Quoted = elixir:'string_to_quoted!'(Content, 1, 1, <<"nofile">>, []),
+  {Value, Binding, _} = elixir:eval_forms(Quoted, [], elixir:env_for_eval([])),
   {Value, lists:sort(Binding)}.
 
 function_arg_do_end_test() ->

lib/elixir/test/erlang/string_test.erl

@@ -3,8 +3,8 @@
 -include_lib("eunit/include/eunit.hrl").
 
 eval(Content) ->
-  {Value, Binding, _} =
-    elixir:eval_forms(elixir:'string_to_quoted!'(Content, 1, 1, <<"nofile">>, []), [], []),
+  Quoted = elixir:'string_to_quoted!'(Content, 1, 1, <<"nofile">>, []),
+  {Value, Binding, _} = elixir:eval_forms(Quoted, [], elixir:env_for_eval([])),
   {Value, Binding}.
 
 extract_interpolations(String) ->

lib/iex/lib/iex/pry.ex

@@ -82,7 +82,7 @@ defmodule IEx.Pry do
 
   def pry(binding, opts) when is_list(opts) do
     vars = for {k, _} when is_atom(k) <- binding, do: {k, nil}
-    pry(binding, opts |> :elixir.env_for_eval() |> :elixir_env.with_vars(vars))
+    pry(binding, opts |> Code.env_for_eval() |> :elixir_env.with_vars(vars))
   end
 
   @doc false