Combining functions with same names and different arities

bryanjos · bryanjos · commit e5dabf516a7d · 2017-06-01T19:23:43.000-05:00
diff --git a/lib/elixir_script/next/passes/translate/clause.ex b/lib/elixir_script/next/passes/translate/clause.ex
@@ -41,7 +41,7 @@ defmodule ElixirScript.Translate.Clause do
       ),
       [
         J.array_expression(patterns),
-        J.function_expression(
+        J.arrow_function_expression(
           params,
           [],
           J.block_statement(body)
@@ -117,7 +117,7 @@ defmodule ElixirScript.Translate.Clause do
     |> process_guards
     |> Form.compile!(state)
 
-    J.function_expression(
+    J.arrow_function_expression(
       params,
       [],
       J.block_statement([
diff --git a/lib/elixir_script/next/passes/translate/examples/example.ex b/lib/elixir_script/next/passes/translate/examples/example.ex
@@ -4,5 +4,4 @@ defmodule Example do
     [d, b, c] = [1, 2, 3]
     [e | g] = [1, 2, 3] 
   end
-
 end
diff --git a/lib/elixir_script/next/passes/translate/form.ex b/lib/elixir_script/next/passes/translate/form.ex
@@ -123,7 +123,7 @@ defmodule ElixirScript.Translate.Form do
       { translated_body, state } = Enum.map_reduce(List.wrap(clause_body), state, &compile(&1, &2))
       
       translated_body = Clause.return_last_statement(translated_body)
-      translated_body = J.function_expression([], [], J.block_statement(translated_body))
+      translated_body = J.arrow_function_expression([], [], J.block_statement(translated_body))
 
       translated_clause = compile(hd(clause), state)
 
@@ -406,7 +406,7 @@ defmodule ElixirScript.Translate.Form do
           ),
           J.identifier(module)
         ),
-        ElixirScript.Translator.Identifier.make_function_name(function, length(params))
+        ElixirScript.Translator.Identifier.make_function_name(function)
       ),
       Enum.map(params, &compile!(&1, state))
     )
@@ -422,7 +422,7 @@ defmodule ElixirScript.Translate.Form do
     {function_name, _} = Map.get(state, :function)
 
     ast = J.call_expression(
-      ElixirScript.Translator.Identifier.make_function_name(function_name, length(params)),
+      ElixirScript.Translator.Identifier.make_function_name(function_name),
       Enum.map(params, &compile!(&1, state))
     )
 
@@ -433,7 +433,7 @@ defmodule ElixirScript.Translate.Form do
     ast = case function_name do
       a when is_atom(a) ->
         J.call_expression(
-          ElixirScript.Translator.Identifier.make_function_name(function_name, length(params)),
+          ElixirScript.Translator.Identifier.make_function_name(function_name),
           Enum.map(params, &compile!(&1, state))
         )
       _ ->
diff --git a/lib/elixir_script/next/passes/translate/forms/call.ex b/lib/elixir_script/next/passes/translate/forms/call.ex
@@ -8,7 +8,7 @@ defmodule ElixirScript.Translate.Forms.Call do
       ElixirScript.Translate.Module.is_js_module(module, state) ->
         ElixirScript.Translator.Identifier.make_extern_function_name(function)
       true ->
-        ElixirScript.Translator.Identifier.make_function_name(function, length(params))            
+        ElixirScript.Translator.Identifier.make_function_name(function)            
     end
 
     ast = J.call_expression(
diff --git a/lib/elixir_script/next/passes/translate/forms/for.ex b/lib/elixir_script/next/passes/translate/forms/for.ex
@@ -10,7 +10,7 @@ defmodule ElixirScript.Translate.Forms.For do
     generators = JS.array_expression(args.generators)
 
     into = args.into || JS.array_expression([])
-    filter = args.filter || JS.function_expression([], [], JS.block_statement([JS.return_statement(JS.identifier("true"))]))
+    filter = args.filter || JS.arrow_function_expression([], [], JS.block_statement([JS.return_statement(JS.identifier("true"))]))
     fun = args.fun
 
 
@@ -128,7 +128,7 @@ defmodule ElixirScript.Translate.Forms.For do
 
     ast = Clause.return_last_statement(ast)
 
-    JS.function_expression(
+    JS.arrow_function_expression(
       state.args,
       [],
       JS.block_statement(ast)
diff --git a/lib/elixir_script/next/passes/translate/forms/try.ex b/lib/elixir_script/next/passes/translate/forms/try.ex
@@ -14,7 +14,7 @@ defmodule ElixirScript.Translate.Forms.Try do
     translated_body = prepare_function_body(try_block, state)
 
     translated_body = JS.block_statement(translated_body)
-    try_block = JS.function_expression([], [], translated_body)
+    try_block = JS.arrow_function_expression([], [], translated_body)
 
     rescue_block = if rescue_block do
       process_rescue_block(rescue_block, state)
@@ -88,7 +88,7 @@ defmodule ElixirScript.Translate.Forms.Try do
     translated_body = prepare_function_body(after_block, state)
     translated_body = JS.block_statement(translated_body)
 
-    JS.function_expression([], [], translated_body)
+    JS.arrow_function_expression([], [], translated_body)
   end
 
   defp prepare_function_body(body, state) do
diff --git a/lib/elixir_script/next/passes/translate/function.ex b/lib/elixir_script/next/passes/translate/function.ex
@@ -32,7 +32,7 @@ defmodule ElixirScript.Translate.Function do
     arg_matches_declaration = J.variable_declaration([arg_matches_declarator], :let)
 
     declarator = J.variable_declarator(
-      ElixirScript.Translator.Identifier.make_function_name(name, arity),
+      ElixirScript.Translator.Identifier.make_function_name(name),
       J.function_expression(
                 [J.rest_element(J.identifier("__function_args__"))],
                 [],
diff --git a/lib/elixir_script/next/passes/translate/module.ex b/lib/elixir_script/next/passes/translate/module.ex
@@ -48,11 +48,21 @@ defmodule ElixirScript.Translate.Module do
       end)
     end
 
+    #we combine our function arities
+    combined_defs = used_defs
+    |> Enum.sort(fn { {name1, arity1}, _, _, _ }, { {name2, arity2}, _, _, _ } -> "#{name1}#{arity1}" < "#{name2}#{arity2}" end)
+    |> Enum.group_by(fn {{name, _}, _, _, _ } -> name end)
+    |> Enum.map(fn {group, funs} ->
+        {_, type, _, _} = hd(funs)
+        Enum.reduce(funs, {{group, nil}, type, [], []}, fn {_, _, _, clauses}, {name, type, context, acc_clauses} ->
+          {name, type, context, acc_clauses ++ clauses}
+        end)
+      end)
 
-    { compiled_functions, _ } = used_defs
+    { compiled_functions, _ } = combined_defs
     |> Enum.map_reduce(state, &Function.compile(&1, &2))
 
-    exports = make_exports(used_defs)
+    exports = make_exports(combined_defs)
 
     js_ast = ElixirScript.ModuleSystems.Namespace.build(
       module,
@@ -67,7 +77,7 @@ defmodule ElixirScript.Translate.Module do
   defp make_exports(reachable_defs) do
     exports = Enum.reduce(reachable_defs, [], fn
       {{name, arity}, :def, _, _}, list ->
-        function_name = ElixirScript.Translator.Identifier.make_function_name(name, arity)
+        function_name = ElixirScript.Translator.Identifier.make_identifier(name)
           list ++ [J.property(function_name, function_name, :init, true)]
       _, list ->
         list
diff --git a/lib/elixir_script/next/passes/translate/protocol.ex b/lib/elixir_script/next/passes/translate/protocol.ex
@@ -11,8 +11,8 @@ defmodule ElixirScript.Translate.Protocol do
   This compiles and consolidates the given protocol
   """
   def compile(module, %{protocol: true, impls: impls, functions: functions} = info, pid) do
-    object = Enum.map(functions, fn {function, arity} ->
-      {Identifier.make_function_name(function, arity), J.function_expression([], [], J.block_statement([]))}
+    object = Enum.map(functions, fn {function, _} ->
+      {Identifier.make_function_name(function), J.function_expression([], [], J.block_statement([]))}
     end)
     |> Enum.map(fn({key, value}) -> ElixirScript.Translate.Forms.Map.make_property(key, value) end)
     |> J.object_expression
diff --git a/lib/elixir_script/translator/kernel/special_forms/identifier.ex b/lib/elixir_script/translator/kernel/special_forms/identifier.ex
@@ -86,9 +86,9 @@ defmodule ElixirScript.Translator.Identifier do
     |> make_alias
   end
 
-  def make_function_name(name, arity) when is_atom(name) do
+  def make_function_name(name) when is_atom(name) do
     name = filter_name(name)
-    JS.identifier("#{name}#{arity}")
+    JS.identifier(name)
   end
 
   def make_extern_function_name(name) do
diff --git a/src/javascript/lib/core/erlang_compat/erlang.js b/src/javascript/lib/core/erlang_compat/erlang.js
@@ -1,18 +1,18 @@
 // http://erlang.org/doc/man/erlang.html
 
-function atom_to_binary2(atom, encoding = Symbol.for('utf8')) {
+function atom_to_binary(atom, encoding = Symbol.for('utf8')) {
   if (encoding !== Symbol.for('utf8')) {
     throw new Error(`unsupported encoding ${encoding}`);
   }
 
   return Symbol.keyFor(atom);
 }
 
-function list_concatenation2(list1, list2) {
+function list_concatenation(list1, list2) {
   return list1.concat(list2);
 }
 
-function list_subtraction2(list1, list2) {
+function list_subtraction(list1, list2) {
   const list = [...list1];
 
   for (const item of list2) {
@@ -27,7 +27,7 @@ function list_subtraction2(list1, list2) {
 }
 
 export default {
-  atom_to_binary2,
-  list_concatenation2,
-  list_subtraction2,
+  atom_to_binary,
+  list_concatenation,
+  list_subtraction,
 };
diff --git a/src/javascript/lib/core/erlang_compat/lists.js b/src/javascript/lib/core/erlang_compat/lists.js
@@ -1,9 +1,9 @@
 // http://erlang.org/doc/man/lists.html
 
-function reverse1(list) {
+function reverse(list) {
   return [...list].reverse();
 }
 
 export default {
-  reverse1,
+  reverse,
 };
diff --git a/src/javascript/lib/core/erlang_compat/maps.js b/src/javascript/lib/core/erlang_compat/maps.js
@@ -5,7 +5,7 @@ const OK = Symbol.for('ok');
 const ERROR = Symbol.for('error');
 const BADMAP = Symbol.for('badmap');
 
-function find2(key, map) {
+function find(key, map) {
   if (map instanceof Object === false) {
     return new ErlangTypes.Tuple(BADMAP, map);
   }
@@ -19,7 +19,7 @@ function find2(key, map) {
   return ERROR;
 }
 
-function fold3(fun, init, map) {
+function fold(fun, init, map) {
   let acc = init;
 
   for (const [key, value] of Object.entries(map)) {
@@ -30,6 +30,6 @@ function fold3(fun, init, map) {
 }
 
 export default {
-  find2,
-  fold3,
+  find,
+  fold,
 };
diff --git a/src/javascript/tests/core/erlang_compat/erlang_spec.js b/src/javascript/tests/core/erlang_compat/erlang_spec.js
@@ -1,23 +1,23 @@
 import test from 'ava';
 import Core from '../../../lib/core';
 
-test('atom_to_binary2', t => {
-  t.is(Core.erlang.atom_to_binary2(Symbol.for('error')), 'error');
+test('atom_to_binary', t => {
+  t.is(Core.erlang.atom_to_binary(Symbol.for('error')), 'error');
   t.is(
-    Core.erlang.atom_to_binary2(Symbol.for('error'), Symbol.for('utf8')),
+    Core.erlang.atom_to_binary(Symbol.for('error'), Symbol.for('utf8')),
     'error'
   );
 
   t.throws(
-    () => Core.erlang.atom_to_binary2(Symbol.for('error'), Symbol.for('utf16')),
+    () => Core.erlang.atom_to_binary(Symbol.for('error'), Symbol.for('utf16')),
     Error
   );
 });
 
-test('list_concatenation2', t => {
-  t.deepEqual(Core.erlang.list_concatenation2([], []), []);
-  t.deepEqual(Core.erlang.list_concatenation2([1], []), [1]);
-  t.deepEqual(Core.erlang.list_concatenation2([1, 2, 3], [4, 5, 6]), [
+test('list_concatenation', t => {
+  t.deepEqual(Core.erlang.list_concatenation([], []), []);
+  t.deepEqual(Core.erlang.list_concatenation([1], []), [1]);
+  t.deepEqual(Core.erlang.list_concatenation([1, 2, 3], [4, 5, 6]), [
     1,
     2,
     3,
@@ -27,10 +27,10 @@ test('list_concatenation2', t => {
   ]);
 });
 
-test('list_subtraction2', t => {
-  t.deepEqual(Core.erlang.list_subtraction2([], []), []);
-  t.deepEqual(Core.erlang.list_subtraction2([1], []), [1]);
-  t.deepEqual(Core.erlang.list_subtraction2([1, 2, 3], [4, 5, 6]), [1, 2, 3]);
-  t.deepEqual(Core.erlang.list_subtraction2([1, 2, 3], [1, 2, 3]), []);
-  t.deepEqual(Core.erlang.list_subtraction2([1, 2, 3], [1, 2]), [3]);
+test('list_subtraction', t => {
+  t.deepEqual(Core.erlang.list_subtraction([], []), []);
+  t.deepEqual(Core.erlang.list_subtraction([1], []), [1]);
+  t.deepEqual(Core.erlang.list_subtraction([1, 2, 3], [4, 5, 6]), [1, 2, 3]);
+  t.deepEqual(Core.erlang.list_subtraction([1, 2, 3], [1, 2, 3]), []);
+  t.deepEqual(Core.erlang.list_subtraction([1, 2, 3], [1, 2]), [3]);
 });
diff --git a/src/javascript/tests/core/erlang_compat/lists_spec.js b/src/javascript/tests/core/erlang_compat/lists_spec.js
@@ -1,6 +1,6 @@
 import test from 'ava';
 import Core from '../../../lib/core';
 
-test('reverse1', t => {
-  t.deepEqual(Core.lists.reverse1([1, 2, 3]), [3, 2, 1]);
+test('reverse', t => {
+  t.deepEqual(Core.lists.reverse([1, 2, 3]), [3, 2, 1]);
 });
diff --git a/src/javascript/tests/core/erlang_compat/maps_spec.js b/src/javascript/tests/core/erlang_compat/maps_spec.js
@@ -1,22 +1,22 @@
 import test from 'ava';
 import Core from '../../../lib/core';
 
-test('find2', t => {
+test('find', t => {
   let myMap = {};
-  let result = Core.maps.find2('t', myMap);
+  let result = Core.maps.find('t', myMap);
   t.is(result, Symbol.for('error'));
 
   myMap = 'Hello';
-  result = Core.maps.find2('t', myMap);
+  result = Core.maps.find('t', myMap);
   t.deepEqual(result.values, [Symbol.for('badmap'), myMap]);
 
   myMap = { t: 'b' };
-  result = Core.maps.find2('t', myMap);
+  result = Core.maps.find('t', myMap);
   t.deepEqual(result.values, [Symbol.for('ok'), 'b']);
 });
 
-test('fold3', t => {
-  let myMap = { a: 1, b: 2 };
-  let result = Core.maps.fold3((k, v, acc) => acc + v, 0, myMap);
+test('fold', t => {
+  const myMap = { a: 1, b: 2 };
+  const result = Core.maps.fold((k, v, acc) => acc + v, 0, myMap);
   t.is(result, 3);
 });
