Bring back no name and simplify var merging

Author: José Valim

lib/elixir/include/elixir.hrl

@@ -11,6 +11,7 @@
 -record(elixir_scope, {
   context=nil,             %% can be assign, guards or nil
   extra=nil,               %% extra information about the context, like fn_match and do_match
+  noname=false,            %% when true, don't add new names (used by try)
   super=false,             %% when true, it means super was invoked
   caller=false,            %% when true, it means caller was invoked
   module=nil,              %% the current module
@@ -23,7 +24,6 @@
   clause_vars=nil,         %% a dict of all variables defined in a particular clause
   extra_guards=nil,        %% extra guards from args expansion
   counter=[],              %% a dict counting the variables defined
-  hygiene_counter=1,       %% a counter for the hygienic vars (start with underscore)
   file=(<<"nofile">>)      %% the current scope filename
 }).
 

lib/elixir/src/elixir_clauses.erl

@@ -82,17 +82,16 @@ do_clauses(_Meta, [], S) ->
 do_clauses(Meta, DecoupledClauses, S) ->
   % Transform tree just passing the variables counter forward
   % and storing variables defined inside each clause.
-  Transformer = fun(X, {SAcc, CAcc, UAcc, VAcc}) ->
+  Transformer = fun(X, {SAcc, UAcc, VAcc}) ->
     { TX, TS } = each_clause(Meta, X, SAcc),
     { TX,
-      { elixir_scope:mergef(S, TS),
-        elixir_scope:merge_counters(CAcc, TS#elixir_scope.counter),
+      { elixir_scope:mergec(S, TS),
         ordsets:union(UAcc, TS#elixir_scope.temp_vars),
         [TS#elixir_scope.clause_vars|VAcc] } }
   end,
 
-  { TClauses, { TS, Counter, Unsafe, ReverseCV } } =
-    lists:mapfoldl(Transformer, {S, S#elixir_scope.counter, S#elixir_scope.unsafe_vars, []}, DecoupledClauses),
+  { TClauses, { TS, Unsafe, ReverseCV } } =
+    lists:mapfoldl(Transformer, {S, S#elixir_scope.unsafe_vars, []}, DecoupledClauses),
 
   % Now get all the variables defined inside each clause
   CV = lists:reverse(ReverseCV),
@@ -105,7 +104,7 @@ do_clauses(Meta, DecoupledClauses, S) ->
   % is the old pointer.
   { FinalVars, FS } = lists:mapfoldl(fun({ Key, Val }, Acc) ->
     normalize_vars(Key, Val, Acc)
-  end, TS#elixir_scope{unsafe_vars=Unsafe, counter=Counter}, AllVars),
+  end, TS#elixir_scope{unsafe_vars=Unsafe}, AllVars),
 
   % Expand all clauses by adding a match operation at the end
   % that defines variables missing in one clause to the others.
@@ -174,54 +173,36 @@ each_clause(_PMeta, { 'after', Meta, [Condition], Expr }, S) ->
 
 has_match_tuple({'receive', _, _, _, _}) ->
   true;
-
 has_match_tuple({'receive', _, _}) ->
   true;
-
 has_match_tuple({'case', _, _, _}) ->
   true;
-
 has_match_tuple({match, _, _, _}) ->
   true;
-
 has_match_tuple({'fun', _, { clauses, _ }}) ->
   false;
-
 has_match_tuple(H) when is_tuple(H) ->
   has_match_tuple(tuple_to_list(H));
-
 has_match_tuple(H) when is_list(H) ->
   lists:any(fun has_match_tuple/1, H);
-
 has_match_tuple(_) -> false.
 
 % Normalize the given var in between clauses
 % by picking one value as reference and retriving
 % its previous value.
-%
-% If the variable starts with _, we cannot reuse it
-% since those shared variables will likely clash.
-
-normalize_vars(Key, { OldValue, OldCounter }, #elixir_scope{vars=Vars,clause_vars=ClauseVars} = S) ->
-  { Value, Counter, CS } =
-    case atom_to_list(OldValue) of
-      "_" ++ _ -> elixir_scope:build_var('_', S);
-      _        -> { OldValue, OldCounter, S }
-    end,
-
-  Tuple = { Value, Counter },
-
-  VS = CS#elixir_scope{
-    vars=orddict:store(Key, Tuple, Vars),
-    clause_vars=orddict:store(Key, Tuple, ClauseVars)
+
+normalize_vars(Key, Value, #elixir_scope{vars=Vars,clause_vars=ClauseVars} = S) ->
+  VS = S#elixir_scope{
+    vars=orddict:store(Key, Value, Vars),
+    clause_vars=orddict:store(Key, Value, ClauseVars)
   },
 
   Expr = case orddict:find(Key, Vars) of
     { ok, { PreValue, _ } } -> { var, 0, PreValue };
     error -> { atom, 0, nil }
   end,
 
-  { { Key, Tuple, Expr }, VS }.
+  { { Key, Value, Expr }, VS }.
 
 % Generate match vars by checking if they were updated
 % or not and assigning the previous value.

lib/elixir/src/elixir_env.erl

@@ -17,7 +17,7 @@ env_to_scope(#elixir_env{module=Module,file=File,function=Function,context=Conte
 env_to_scope_with_vars(#elixir_env{} = Env, Vars) ->
   (env_to_scope(Env))#elixir_scope{
     vars=orddict:from_list(Vars),
-    hygiene_counter=length(Vars)+1
+    counter=[{'_',length(Vars)}]
   }.
 
 %% SCOPE MERGING

lib/elixir/src/elixir_scope.erl

@@ -4,7 +4,7 @@
   load_binding/2, dump_binding/2,
   format_error/1, warn_unsafe/3,
   mergev/2, mergec/2, mergef/2,
-  merge_vars/2, merge_opt_vars/2, merge_counters/2
+  merge_vars/2, merge_opt_vars/2
 ]).
 -include("elixir.hrl").
 
@@ -47,7 +47,8 @@ translate_var(Meta, Name, Kind, RS) when is_atom(Kind); is_integer(Kind) ->
           { NewVar, Counter, NS } =
             if
               Kind /= nil -> build_var('_', S);
-              true -> build_var(Name, S)
+              Exists orelse S#elixir_scope.noname -> build_var(Name, S);
+              true -> { Name, 0, S }
             end,
 
           FS = NS#elixir_scope{
@@ -65,19 +66,10 @@ translate_var(Meta, Name, Kind, RS) when is_atom(Kind); is_integer(Kind) ->
       { { var, Line, Current }, S }
   end.
 
-build_var('_', #elixir_scope{hygiene_counter=Cnt} = S) ->
-  build_var('_', Cnt, S#elixir_scope{hygiene_counter=Cnt+1});
 build_var(Key, S) ->
-  New = orddict:update(Key, fun(Old) -> Old + 1 end, 0, S#elixir_scope.counter),
-  build_var(Key, orddict:fetch(Key, New), S#elixir_scope{counter=New}).
-
-build_var(Key, Cnt, S) ->
-  Var =
-    case Cnt of
-      0 -> Key;
-      _ -> ?atom_concat([Key, "@", Cnt])
-    end,
-  { Var, Cnt, S }.
+  New = orddict:update_counter(Key, 1, S#elixir_scope.counter),
+  Cnt = orddict:fetch(Key, New),
+  { ?atom_concat([Key, "@", Cnt]), Cnt, S#elixir_scope{counter=New} }.
 
 warn_unsafe(Meta, Tuple, S) ->
   case ordsets:is_element(Tuple, S#elixir_scope.unsafe_vars) andalso
@@ -119,25 +111,19 @@ mergec(S1, S2) ->
   S1#elixir_scope{
     counter=S2#elixir_scope.counter,
     super=S2#elixir_scope.super,
-    caller=S2#elixir_scope.caller,
-    hygiene_counter=S2#elixir_scope.hygiene_counter
+    caller=S2#elixir_scope.caller
   }.
 
 %% Similar to mergec but does not merge the user vars counter.
 
 mergef(S1, S2) ->
   S1#elixir_scope{
     super=S2#elixir_scope.super,
-    caller=S2#elixir_scope.caller,
-    hygiene_counter=S2#elixir_scope.hygiene_counter
+    caller=S2#elixir_scope.caller
   }.
 
 %% Mergers.
 
-merge_counters(C, C) -> C;
-merge_counters(C1, C2) ->
-  orddict:merge(fun(_K, V1, V2) -> max(V1, V2) end, C1, C2).
-
 merge_vars(V, V) -> V;
 merge_vars(V1, V2) ->
   orddict:merge(fun var_merger/3, V1, V2).
@@ -154,10 +140,10 @@ var_merger(_Var, _K1, K2) -> K2.
 %% BINDINGS
 
 load_binding(Binding, Scope) ->
-  { NewBinding, NewVars, NewCounter } = load_binding(Binding, [], [], 1),
+  { NewBinding, NewVars, NewCounter } = load_binding(Binding, [], [], 0),
   { NewBinding, Scope#elixir_scope{
     vars=NewVars,
-    hygiene_counter=NewCounter
+    counter=[{'_',NewCounter}]
   } }.
 
 load_binding([{Key,Value}|T], Binding, Vars, Counter) ->

lib/elixir/src/elixir_translator.erl

@@ -78,7 +78,8 @@ translate({'case', Meta, [Expr, KV]}, S) when is_list(KV) ->
 
 %% Try
 
-translate({'try', Meta, [Clauses]}, S) when is_list(Clauses) ->
+translate({'try', Meta, [Clauses]}, RS) when is_list(Clauses) ->
+  S  = RS#elixir_scope{noname=true},
   Do = proplists:get_value('do', Clauses, nil),
   { TDo, SB } = elixir_translator:translate(Do, S),
 
@@ -91,7 +92,8 @@ translate({'try', Meta, [Clauses]}, S) when is_list(Clauses) ->
   Else = elixir_clauses:get_pairs(else, Clauses),
   { TElse, SE } = elixir_clauses:clauses(Meta, Else, mergec(S, SA)),
 
-  { { 'try', ?line(Meta), unblock(TDo), TElse, TCatch, unblock(TAfter) }, mergec(S, SE) };
+  SF = (mergec(S, SE))#elixir_scope{noname=RS#elixir_scope.noname},
+  { { 'try', ?line(Meta), unblock(TDo), TElse, TCatch, unblock(TAfter) }, SF };
 
 %% Receive
 

lib/elixir/src/elixir_try.erl

@@ -5,15 +5,11 @@
 clauses(_Meta, Clauses, S) ->
   Catch  = elixir_clauses:get_pairs('catch', Clauses),
   Rescue = elixir_clauses:get_pairs(rescue, Clauses),
-  Transformer = fun(X, { SAcc, CAcc }) ->
+  Transformer = fun(X, SAcc) ->
     { TX, TS } = each_clause(X, SAcc),
-    { TX,
-      { elixir_scope:mergef(S, TS),
-        elixir_scope:merge_counters(CAcc, TS#elixir_scope.counter) } }
+    { TX, elixir_scope:mergec(S, TS) }
   end,
-  { TClauses, { TS, TC } } =
-    lists:mapfoldl(Transformer, { S, S#elixir_scope.counter }, Rescue ++ Catch),
-  { TClauses, TS#elixir_scope{counter=TC} }.
+  lists:mapfoldl(Transformer, S, Rescue ++ Catch).
 
 each_clause({ 'catch', Meta, Raw, Expr }, S) ->
   { Args, Guards } = elixir_clauses:extract_splat_guards(Raw),