Use a main counter for hygienic variables

Author: José Valim

lib/elixir/include/elixir.hrl

@@ -11,7 +11,6 @@
 -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
@@ -24,6 +23,7 @@
   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

@@ -83,9 +83,9 @@ 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}) ->
-    { TX, TS } = each_clause(Meta, X, S),
+    { TX, TS } = each_clause(Meta, X, SAcc),
     { TX,
-      { elixir_scope:mergef(SAcc, TS),
+      { elixir_scope:mergef(S, TS),
         elixir_scope:merge_counters(CAcc, TS#elixir_scope.counter),
         ordsets:union(UAcc, TS#elixir_scope.temp_vars),
         [TS#elixir_scope.clause_vars|VAcc] } }

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),
-    counter=[{'_',length(Vars)}]
+    hygiene_counter=length(Vars)+1
   }.
 
 %% SCOPE MERGING

lib/elixir/src/elixir_fn.erl

@@ -6,8 +6,8 @@
 translate(Meta, Clauses, S) ->
   Transformer = fun({ '->', CMeta, [ArgsWithGuards, Expr] }, Acc) ->
     { Args, Guards } = elixir_clauses:extract_splat_guards(ArgsWithGuards),
-    elixir_clauses:clause(?line(CMeta), fun translate_fn_match/2, Args,
-                          Expr, Guards, elixir_scope:mergef(S, Acc))
+    { TClause, TS  } = elixir_clauses:clause(?line(CMeta), fun translate_fn_match/2, Args, Expr, Guards, Acc),
+    { TClause, elixir_scope:mergef(S, TS) }
   end,
 
   { TClauses, NS } = lists:mapfoldl(Transformer, S, Clauses),

lib/elixir/src/elixir_scope.erl

@@ -65,15 +65,19 @@ translate_var(Meta, Name, Kind, RS) when is_atom(Kind); is_integer(Kind) ->
       { { var, Line, Current }, S }
   end.
 
-build_var(Key, #elixir_scope{counter=Dict} = S) ->
-  New = orddict:update(Key, fun(Old) -> Old + 1 end, 0, Dict),
-  Cnt = orddict:fetch(Key, New),
+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 when Key /= '_' -> Key;
+      0 -> Key;
       _ -> ?atom_concat([Key, "@", Cnt])
     end,
-  { Var, Cnt, S#elixir_scope{counter=New} }.
+  { Var, Cnt, S }.
 
 warn_unsafe(Meta, Tuple, S) ->
   case ordsets:is_element(Tuple, S#elixir_scope.unsafe_vars) andalso
@@ -108,22 +112,24 @@ mergev(S1, S2) ->
     temp_vars=merge_opt_vars(T1, T2)
   }.
 
-%% Receives two scopes and keeps the first with all
-%% the flags from the second.
-mergef(S1, S2) ->
-  S1#elixir_scope{
-    super=S2#elixir_scope.super,
-    caller=S2#elixir_scope.caller
-  }.
-
 %% Receives two scopes and return the first scope with
 %% counters and flags from the later.
 
 mergec(S1, S2) ->
   S1#elixir_scope{
     counter=S2#elixir_scope.counter,
     super=S2#elixir_scope.super,
-    caller=S2#elixir_scope.caller
+    caller=S2#elixir_scope.caller,
+    hygiene_counter=S2#elixir_scope.hygiene_counter
+  }.
+
+%% 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
   }.
 
 %% Mergers.
@@ -148,12 +154,10 @@ var_merger(_Var, _K1, K2) -> K2.
 %% BINDINGS
 
 load_binding(Binding, Scope) ->
-  { NewBinding, NewVars, NewCounter } = load_binding(Binding, [], [], 0),
+  { NewBinding, NewVars, NewCounter } = load_binding(Binding, [], [], 1),
   { NewBinding, Scope#elixir_scope{
     vars=NewVars,
-    match_vars=[],
-    clause_vars=nil,
-    counter=[{'_',NewCounter}]
+    hygiene_counter=NewCounter
   } }.
 
 load_binding([{Key,Value}|T], Binding, Vars, Counter) ->

lib/elixir/src/elixir_try.erl

@@ -6,9 +6,9 @@ clauses(_Meta, Clauses, S) ->
   Catch  = elixir_clauses:get_pairs('catch', Clauses),
   Rescue = elixir_clauses:get_pairs(rescue, Clauses),
   Transformer = fun(X, { SAcc, CAcc }) ->
-    { TX, TS } = each_clause(X, S),
+    { TX, TS } = each_clause(X, SAcc),
     { TX,
-      { elixir_scope:mergef(SAcc, TS),
+      { elixir_scope:mergef(S, TS),
         elixir_scope:merge_counters(CAcc, TS#elixir_scope.counter) } }
   end,
   { TClauses, { TS, TC } } =