Prune binding from env and on literals

Author: josevalim

lib/elixir/src/elixir.erl

@@ -277,8 +277,11 @@ eval_forms(Tree, Binding, OrigE, Opts) ->
   {Erl, NewErlS, NewExS, NewE} = quoted_to_erl(Tree, ErlS, ExS, E),
 
   case Erl of
-    {atom, _, Atom} ->
-      {Atom, Binding, NewE};
+    {Literal, _, Literal} when Literal == atom; Literal == float; Literal == integer ->
+      if
+        Prune -> {Literal, [], NewE};
+        true -> {Literal, Binding, NewE}
+      end;
 
     _  ->
       Exprs =
@@ -289,8 +292,12 @@ eval_forms(Tree, Binding, OrigE, Opts) ->
 
       ExternalHandler = eval_external_handler(NewE),
       {value, Value, NewBinding} = erl_eval:exprs(Exprs, ErlBinding, none, ExternalHandler),
+
       PruneBefore = if Prune -> length(Binding); true -> 0 end,
-      {Value, elixir_erl_var:dump_binding(NewBinding, NewErlS, NewExS, PruneBefore), NewE}
+      {DumpedBinding, DumpedVars} =
+        elixir_erl_var:dump_binding(NewBinding, NewErlS, NewExS, PruneBefore),
+
+      {Value, DumpedBinding, NewE#{versioned_vars := DumpedVars}}
   end.
 
 %% TODO: Remove conditional once we require Erlang/OTP 25+.
@@ -365,10 +372,10 @@ quoted_to_erl(Quoted, E) ->
   quoted_to_erl(Quoted, ErlS, ExS, E).
 
 quoted_to_erl(Quoted, ErlS, ExS, Env) ->
-  {Expanded, #elixir_ex{vars={ReadVars, _}} = NewExS, NewEnv} =
+  {Expanded, NewExS, NewEnv} =
     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}}.
+  {Erl, NewErlS, NewExS, NewEnv}.
 
 %% Converts a given string (charlist) into quote expression
 

lib/elixir/src/elixir_erl_var.erl

@@ -106,23 +106,25 @@ dump_binding(Binding, ErlS, ExS, PruneBefore) ->
   #elixir_ex{vars={ExVars, _}, unused={Unused, _}} = ExS,
 
   maps:fold(fun
-    ({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) ->
+    %% If the variable is part of the pruning (usually the input binding)
+    %% and is unused, we removed it from vars.
+    (Pair, Version, {B, V})
+    when Version < PruneBefore, map_get({Pair, Version}, Unused) /= false ->
+      {B, maps:remove(Pair, V)};
+
+    ({Var, Kind} = Pair, Version, {B, V}) when is_atom(Kind) ->
       Key = case Kind of
         nil -> Var;
         _ -> Pair
       end,
 
       ErlName = maps:get(Version, ErlVars),
       Value = find_binding(ErlName, Binding),
-      [{Key, Value} | Acc];
+      {[{Key, Value} | B], V};
 
     (_, _, Acc) ->
       Acc
-  end, [], ExVars).
+  end, {[], ExVars}, ExVars).
 
 find_binding(ErlName, Binding = #{}) ->
   case Binding of

lib/elixir/test/elixir/code_test.exs

@@ -181,29 +181,29 @@ defmodule CodeTest do
     env = Code.env_for_eval(__ENV__)
 
     fun = fn quoted, binding ->
-      {_, binding, _} = Code.eval_quoted_with_env(quoted, binding, env, prune_binding: true)
-      binding
+      {_, binding, env} = Code.eval_quoted_with_env(quoted, binding, env, prune_binding: true)
+      {binding, Macro.Env.vars(env)}
     end
 
-    assert fun.(quote(do: 123), []) == []
-    assert fun.(quote(do: 123), x: 2, y: 3) == []
+    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) = 1), []) == {[x: 1], [x: nil]}
+    assert fun.(quote(do: var!(x) = 1), x: 2, y: 3) == {[x: 1], [x: nil]}
 
-    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}, 1}], [x: :foo]}
+    assert fun.(quote(do: var!(x, :foo) = 1), x: 2, y: 3) == {[{{:x, :foo}, 1}], [x: :foo]}
 
     assert fun.(quote(do: var!(x, :foo) = 1), [{{:x, :foo}, 2}, {{:y, :foo}, 3}]) ==
-             [{{:x, :foo}, 1}]
+             {[{{:x, :foo}, 1}], [x: :foo]}
 
-    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, :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) end), x: 2, y: 3) == {[x: 2], [x: nil]}
 
     assert fun.(quote(do: fn -> var!(x, :foo) end), [{{:x, :foo}, 2}, {{:y, :foo}, 3}]) ==
-             [{{:x, :foo}, 2}]
+             {[{{:x, :foo}, 2}], [x: :foo]}
   end
 
   test "compile_file/1" do