Now appending the counter value to variables if exists

bryanjos · bryanjos · commit 315931e5a491 · 2017-08-07T20:26:01.000-05:00
fixes #346
diff --git a/lib/elixir_script/passes/translate/form.ex b/lib/elixir_script/passes/translate/form.ex
@@ -386,14 +386,18 @@ defmodule ElixirScript.Translate.Form do
     end
   end
 
-  def compile({:default, _, _}, state) do
+  def compile({:default, meta, _}, state) do
+    counter = Pattern.get_counter(meta)
+
     var = :__default__
-    var = Pattern.get_variable_name(to_string(var), state)
+    var = Pattern.get_variable_name(to_string(var) <> counter, state)
     { ElixirScript.Translate.Identifier.make_identifier(var), state }
   end
 
-  def compile({var, _, _}, state) do
-    var = Pattern.get_variable_name(to_string(var), state)
+  def compile({var, meta, _}, state) do
+    counter = Pattern.get_counter(meta)
+
+    var = Pattern.get_variable_name(to_string(var) <> counter, state)
     { ElixirScript.Translate.Identifier.make_identifier(var), state }
   end
 
diff --git a/lib/elixir_script/passes/translate/forms/pattern.ex b/lib/elixir_script/passes/translate/forms/pattern.ex
@@ -194,9 +194,12 @@ defmodule ElixirScript.Translate.Forms.Pattern do
 
   defp process_pattern({:<<>>, _, elements}, state) do
     params = Enum.reduce(elements, [], fn
-      ({:::, _, [{ variable, _, params }, _]}, state) when is_nil(params)
+      ({:::, _, [{ _, _, params } = ast, _]}, state) when is_nil(params)
                                                       when is_list(params) and length(params) == 0 ->
-        state ++ [ElixirScript.Translate.Identifier.make_identifier(variable)]
+
+        var_str = make_identifier(ast)
+        var_atom = String.to_atom(var_str)
+        state ++ [ElixirScript.Translate.Identifier.make_identifier(var_atom)]
       _, state ->
         state
     end)
@@ -215,16 +218,18 @@ defmodule ElixirScript.Translate.Forms.Pattern do
     { [PM.starts_with(prefix)], [Form.compile!(value, state)] }
   end
 
-  defp process_pattern({:=, _, [{name, _, _}, right]}, state) when not name in [:%, :{}, :^, :%{}, :<<>>] do
-    unify(name, right, state)
+  defp process_pattern({:=, _, [{name, _, _} = target, right]}, state) when not name in [:%, :{}, :^, :%{}, :<<>>] do
+    unify(target, right, state)
   end
 
-  defp process_pattern({:=, _, [left, {name, _, _}]}, state) when not name in [:%, :{}, :^, :%{}, :<<>>] do
-    unify(name, left, state)
+  defp process_pattern({:=, _, [left, {name, _, _} = target]}, state) when not name in [:%, :{}, :^, :%{}, :<<>>] do
+    unify(target, left, state)
   end
 
-  defp process_pattern({var, _, a}, _) when is_atom(a) do
-    { [PM.parameter(J.literal(to_string(var)))], [ElixirScript.Translate.Identifier.make_identifier(var)] }
+  defp process_pattern({_, _, a} = ast, _) when is_atom(a) do
+    var_str = make_identifier(ast)
+    var_atom = String.to_atom(var_str)
+    { [PM.parameter(J.literal(var_str))], [ElixirScript.Translate.Identifier.make_identifier(var_atom)] }
   end
 
   defp process_pattern(ast, state) do
@@ -240,6 +245,22 @@ defmodule ElixirScript.Translate.Forms.Pattern do
 
   defp unify(target, source, state) do
     { patterns, params } = do_compile([source], state)
-    { [PM.capture(hd(patterns))], params ++ [ElixirScript.Translate.Identifier.make_identifier(target)] }
+    { [_] , [param] } = process_pattern(target, state)
+    { [PM.capture(hd(patterns))], params ++ [param] }
+  end
+
+  def get_counter(meta) do
+    case Keyword.get(meta, :counter, nil) do
+      nil -> ""
+      counter ->
+        counter
+        |> Kernel.abs()
+        |> to_string()
+    end
+  end
+
+  defp make_identifier({var, meta, _}) do
+    counter = get_counter(meta)
+    to_string(var) <> counter
   end
 end
