Eval should take into account other contexts

Author: José Valim

lib/elixir/lib/code.ex

@@ -56,7 +56,7 @@ defmodule Code do
   end
 
   @doc """
-  Evaluates the contents given by `string`. The second argument is 
+  Evaluates the contents given by `string`. The second argument is
   a keyword list of variable bindings, followed by a keyword list of
   environment options. Those options can be:
 
@@ -83,9 +83,13 @@ defmodule Code do
   etc.
 
   Returns a tuple of the form `{ value, binding }`,
-  where `value` is the the value returned from evaluating `string`; `binding`
-  is a keyword list with the value of all variable bindings after evaluating
-  `string`. If an error occurs while evaluating `string` an exception will be raised.
+  where `value` is the the value returned from evaluating `string`.
+  If an error occurs while evaluating `string` an exception will be raised.
+
+  `binding` is a keyword list with the value of all variable bindings
+  after evaluating `string`. The binding key is usually an atom, but it
+  may be a tuple for variables defined in another contexts that are not
+  the main one.
 
   ## Examples
 
@@ -95,7 +99,7 @@ defmodule Code do
       iex> Code.eval_string("c = a + b", [a: 1, b: 2], __ENV__)
       {3, [a: 1, b: 2, c: 3]}
 
-      iex> Code.eval_string("a = a + b", [a: 1, b: 2])          
+      iex> Code.eval_string("a = a + b", [a: 1, b: 2])
       {3, [a: 3, b: 2]}
 
   For convenience, you can pass `__ENV__` as the `opts` argument and
@@ -362,7 +366,7 @@ defmodule Code do
   modules need to be loaded upfront or explicitly.
 
   Therefore, this function is used to check if a module is loaded
-  before using it and allows one to react accordingly. For example, the `URI` 
+  before using it and allows one to react accordingly. For example, the `URI`
   module uses this function to check if a specific parser exists for a given
   URI scheme.
 
@@ -397,7 +401,7 @@ defmodule Code do
   @doc """
   Ensures the given module is compiled and loaded. If the module
   is already loaded, it works as no-op. If the module was not
-  loaded yet, it checks if it needs to be compiled first and 
+  loaded yet, it checks if it needs to be compiled first and
   then tries to load it.
 
   If it succeeds loading the module, it returns

lib/elixir/src/elixir.erl

@@ -2,9 +2,8 @@
 -behaviour(application).
 -export([main/1, start_cli/0,
   scope_for_eval/1, scope_for_eval/2,
-  eval/2, eval/3, eval/4,
-  eval_quoted/2, eval_quoted/3, eval_quoted/4,
-  eval_forms/3, translate_forms/3]).
+  eval/2, eval/3, eval/4, eval_forms/3,
+  eval_quoted/2, eval_quoted/3, eval_quoted/4]).
 -include("elixir.hrl").
 
 %% Top level types
@@ -124,17 +123,16 @@ eval_quoted(Tree, Binding, Line, #elixir_scope{} = S) when is_integer(Line) ->
 %% Handle forms evaluation internally, it is an
 %% internal API not meant for external usage.
 
-translate_forms(Tree, Binding, Opts) when is_list(Opts) ->
-  translate_forms(Tree, Binding, scope_for_eval(Opts));
-
-translate_forms(Tree, Binding, #elixir_scope{} = Scope) ->
-  elixir_translator:translate(Tree, elixir_scope:vars_from_binding(Scope, Binding)).
+eval_forms(Tree, Binding, Opts) when is_list(Opts) ->
+  eval_forms(Tree, Binding, scope_for_eval(Opts));
 
 eval_forms(Tree, Binding, Scope) ->
-  { ParseTree, NewScope } = translate_forms(Tree, Binding, Scope),
-  case ParseTree of
-    [] -> { nil, Binding, NewScope };
+  { ParsedBinding, ParsedScope } = elixir_scope:load_binding(Binding, Scope, nil),
+  { Exprs, NewScope } = elixir_translator:translate(Tree, ParsedScope),
+  case Exprs of
+    [] ->
+      { nil, Binding, NewScope };
     _  ->
-      {value, Value, NewBinding} = erl_eval:exprs(ParseTree, elixir_scope:binding_for_eval(Binding, nil)),
-      {Value, elixir_scope:binding_from_vars(NewScope, NewBinding), NewScope }
+      { value, Value, NewBinding } = erl_eval:exprs(Exprs, ParsedBinding),
+      { Value, elixir_scope:dump_binding(NewBinding, NewScope), NewScope }
   end.

lib/elixir/src/elixir_module.erl

@@ -8,7 +8,7 @@
 -define(persisted_attr, '__persisted_attributes').
 
 eval_quoted(Module, Quoted, RawBinding, Opts) ->
-  Binding = elixir_scope:binding_for_eval(RawBinding, Module),
+  Binding = orddict:store('_@MODULE', Module, RawBinding),
   Scope   = scope_for_eval(Module, Opts),
 
   elixir_def:reset_last(Module),
@@ -385,8 +385,7 @@ else_clause() ->
 % HELPERS
 
 eval_callbacks(Line, Module, Name, Args, RawS) ->
-  Binding   = elixir_scope:binding_for_eval([], Module),
-  S         = elixir_scope:vars_from_binding(RawS, Binding),
+  { Binding, S } = elixir_scope:load_binding([], RawS, Module),
   Callbacks = lists:reverse(ets:lookup_element(data_table(Module), Name, 2)),
   Meta      = [{line,Line},{require,false}],
 

lib/elixir/src/elixir_scope.erl

@@ -5,7 +5,7 @@
   serialize/1, deserialize/1,
   serialize_with_vars/2, deserialize_with_vars/2,
   to_erl_env/1, to_ex_env/1,
-  vars_from_binding/2, binding_for_eval/2, binding_from_vars/2,
+  load_binding/3, dump_binding/2,
   umergev/2, umergec/2, umergea/2, merge_clause_vars/2
 ]).
 -include("elixir.hrl").
@@ -207,37 +207,40 @@ var_number([], Acc)      -> list_to_integer(lists:reverse(Acc)).
 
 %% Setup the vars in scope from binding
 
-vars_from_binding(Scope, Binding) ->
-  Scope#elixir_scope{
-    vars=binding_dict(Binding),
+load_binding(Binding, Scope, Module) ->
+  { NewBinding, NewVars, NewCounter } = load_binding(Binding, [], [], 0, Module),
+  { NewBinding, Scope#elixir_scope{
+    vars=NewVars,
     temp_vars=[],
     clause_vars=nil,
-    counter=[]
-  }.
-
-binding_dict(List) -> binding_dict(List, orddict:new()).
-binding_dict([{{H,Kind},_}|T], Dict) -> binding_dict(T, orddict:store({ H, Kind }, H, Dict));
-binding_dict([{H,_}|T], Dict) -> binding_dict(T, orddict:store({ H, nil }, H, Dict));
-binding_dict([], Dict) -> Dict.
-
-binding_for_eval(Binding, Module) ->
-  Keyword = orddict:from_list(Binding),
-  case orddict:find('_@MODULE', Keyword) of
-    { ok, _ } -> Keyword;
-    _ -> orddict:store('_@MODULE', Module, Keyword)
-  end.
-
-binding_from_vars(#elixir_scope{vars=Vars}, Binding) ->
-  binding_from_vars(Binding, [], Binding, Vars).
-
-binding_from_vars([{Var,_}|T], Acc, Binding, Vars) ->
-  case lists:member($@, atom_to_list(Var)) of
-    true  ->
-      binding_from_vars(T, Acc, Binding, Vars);
-    false ->
-      RealName  = orddict:fetch({ Var, nil }, Vars),
-      RealValue = proplists:get_value(RealName, Binding, nil),
-      binding_from_vars(T, [{Var, RealValue}|Acc], Binding, Vars)
-  end;
-
-binding_from_vars([], Acc, _Binding, _Vars) -> lists:reverse(Acc).
+    counter=[{'',NewCounter}]
+  } }.
+
+load_binding([{'_@MODULE',Value}|T], Binding, Vars, Counter, _Module) ->
+  load_binding(T, Binding, Vars, Counter, Value);
+load_binding([{Key,Value}|T], Binding, Vars, Counter, Module) ->
+  Actual = case Key of
+    { _Name, _Kind } -> Key;
+    Name when is_atom(Name) -> { Name, nil }
+  end,
+  InternalName = ?atom_concat(["_@", Counter]),
+  load_binding(T,
+    [{InternalName,Value}|Binding],
+    orddict:store(Actual, InternalName, Vars),
+    Counter + 1, Module);
+load_binding([], Binding, Vars, Counter, Module) ->
+  { lists:reverse([{'_@MODULE',Module}|Binding]), Vars, Counter }.
+
+dump_binding(Binding, #elixir_scope{vars=Vars}) ->
+  dump_binding(Vars, Binding, []).
+
+dump_binding([{{Var,Kind}=Key,InternalName}|T], Binding, Acc) when is_atom(Kind) ->
+  Actual = case Kind of
+    nil -> Var;
+    _   -> Key
+  end,
+  Value = proplists:get_value(InternalName, Binding, nil),
+  dump_binding(T, Binding, orddict:store(Actual, Value, Acc));
+dump_binding([_|T], Binding, Acc) ->
+  dump_binding(T, Binding, Acc);
+dump_binding([], _Binding, Acc) -> Acc.

lib/elixir/test/elixir/code_test.exs

@@ -19,6 +19,10 @@ defmodule CodeTest do
     assert { 3, _ } = Code.eval_string("a + b", [a: 1, b: 2], __ENV__.location)
   end
 
+  test :eval_string_with_other_context do
+    assert Code.eval_string("var!(a, Sample) = 1") == { 1, [{{:a,Sample},1}] }
+  end
+
   test :eval_with_unnamed_scopes do
     assert { RuntimeError[], [a: RuntimeError[]] } =
            Code.eval_string("a = (try do (raise \"hello\") rescue e -> e end)")