Fixes from compiler testing. Replace String compilation with ElixirScript.String

bryanjos · bryanjos · commit 48e3225e2861 · 2017-06-11T17:23:15.000-05:00
diff --git a/.tool-versions b/.tool-versions
@@ -1,3 +1,3 @@
-erlang ref-OTP-20.0-rc1
-elixir ref-9873e42
-nodejs 7.10.0
+erlang ref-OTP-20.0-rc2
+elixir ref-d19a92b
+nodejs 8.1.0
diff --git a/lib/elixir_script/next/passes/find_used_functions.ex b/lib/elixir_script/next/passes/find_used_functions.ex
@@ -46,34 +46,23 @@ defmodule ElixirScript.FindUsedFunctions do
 
   defp walk_module(module, function, arity, pid) do
     function = {function, arity}
-
     unless ModuleState.has_used?(pid, module, function) do
-      %{
-        attributes: _attrs, 
-        compile_opts: _compile_opts,
-        definitions: defs,
-        file: _file,
-        line: _line, 
-        module: ^module, 
-        unreachable: unreachable
-      } = ModuleState.get_module(pid, module)
+      info = ModuleState.get_module(pid, module)
 
       state = %{
         pid: pid,
         module: module
       }
 
-      reachable_defs = Enum.filter(defs, fn
-        { _, type, _, _} when type in [:defmacro, :defmacrop] -> false
-        { name, _, _, _} -> not(name in [function])
-        _ -> true
-      end)
-
-      Enum.each(reachable_defs, fn({name, _type, _, _clauses}) -> 
-        ModuleState.add_used(state.pid, module, name)
-      end)
+      reachable_def = Enum.find(Map.get(info, :definitions, []), fn { name, _, _, _} -> name == function end)
 
-      Enum.each(reachable_defs, &walk(&1, state))
+      case reachable_def do
+        nil ->
+          nil
+        {name, _type, _, _clauses} = func ->
+          ModuleState.add_used(state.pid, module, name)
+          walk(func, state)
+      end
     end
   end
 
@@ -105,6 +94,15 @@ defmodule ElixirScript.FindUsedFunctions do
     walk({[], params, [], body}, state)
   end
 
+  defp walk({:|, _, [head, tail]}, state) do
+    walk(head, state)
+    walk(tail, state)
+  end
+
+  defp walk({:::, _, _}, state) do
+    nil
+  end
+
   defp walk(form, state) when is_list(form) do
     Enum.each(form, &walk(&1, state))
   end
@@ -234,10 +232,6 @@ defmodule ElixirScript.FindUsedFunctions do
     walk(params, state)
   end
 
-  defp walk({function, _, params}, state) when function in [:|, :::] do
-    nil
-  end
-
   defp walk({function, _, params}, state) when is_atom(function) and is_list(params) do
     walk_module(state.module, function, length(params), state.pid)
     Enum.each(params, &walk(&1, state))
diff --git a/lib/elixir_script/next/passes/find_used_modules.ex b/lib/elixir_script/next/passes/find_used_modules.ex
@@ -99,12 +99,21 @@ defmodule ElixirScript.FindUsedModules do
     walk({[], params, [], body}, state)
   end
 
+  defp walk({:|, _, [head, tail]}, state) do
+    walk(head, state)
+    walk(tail, state)
+  end
+
+  defp walk({:::, _, _}, state) do
+    nil
+  end
+
   defp walk(form, state) when is_list(form) do
     Enum.each(form, &walk(&1, state))
   end
 
   defp walk(form, state) when is_atom(form) and form not in [BitString, Function, PID, Port, Reference, Any, Elixir] do
-    if ElixirScript.Translate.Module.is_elixir_module(form) do
+    if ElixirScript.Translate.Module.is_elixir_module(form) and !ElixirScript.Translate.Module.is_js_module(form, state) do
       if ModuleState.get_module(state.pid, form) == nil do
         execute(form, state.pid)
       end
@@ -133,7 +142,7 @@ defmodule ElixirScript.FindUsedModules do
   end
 
   defp walk({:%, _, [module, params]}, state) do
-    if ElixirScript.Translate.Module.is_elixir_module(module) do
+    if ElixirScript.Translate.Module.is_elixir_module(module) and !ElixirScript.Translate.Module.is_js_module(module, state) do
       if ModuleState.get_module(state.pid, module) == nil do
         do_execute(module, state.pid)
       end
@@ -233,7 +242,6 @@ defmodule ElixirScript.FindUsedModules do
         if ModuleState.get_module(state.pid, module) == nil do
           execute(module, state.pid)
         end
-        ModuleState.add_used(state.pid, module, {function, length(params)})
       true ->
         nil         
     end
@@ -245,8 +253,7 @@ defmodule ElixirScript.FindUsedModules do
     walk(params, state)
   end
 
-  defp walk({function, _, params}, state) when is_atom(function) and is_list(params) do
-    ModuleState.add_used(state.pid, state.module, {function, length(params)})    
+  defp walk({function, _, params}, state) when is_atom(function) and is_list(params) do   
     Enum.each(params, &walk(&1, state))
   end
 
diff --git a/lib/elixir_script/next/passes/translate/examples/example.ex b/lib/elixir_script/next/passes/translate/examples/example.ex
diff --git a/lib/elixir_script/next/passes/translate/examples/size.ex b/lib/elixir_script/next/passes/translate/examples/size.ex
diff --git a/lib/elixir_script/next/passes/translate/form.ex b/lib/elixir_script/next/passes/translate/form.ex
@@ -24,6 +24,18 @@ defmodule ElixirScript.Translate.Form do
     { J.literal(form), state }
   end
 
+  def compile({:|, _, [head, tail]}, state) do
+    ast = J.call_expression(
+      J.member_expression(
+        J.array_expression([compile!(head, state)]),
+        J.identifier("concat")
+      ),
+      [compile!(tail, state)]
+    )
+
+    { ast, state }
+  end
+
   def compile(form, state) when is_list(form) do
     ast = J.array_expression(
       Enum.map(form, &compile!(&1, state))
@@ -151,7 +163,7 @@ defmodule ElixirScript.Translate.Form do
   def compile({:receive, context, [blocks]}, state) do
     line = Keyword.get(context, :line, 1)
     {function, arity} = Map.get(state, :function)
-    Logger.warn "receive not supported, Module: #{inspect state.module}, Function: #{function}/#{arity}, Line: #{line}"
+    Logger.warn "receive not supported, Module: #{inspect state.module}, Function: #{function}, Line: #{line}"
     Receive.compile(blocks, state)
   end
 
diff --git a/lib/elixir_script/next/passes/translate/forms/remote.ex b/lib/elixir_script/next/passes/translate/forms/remote.ex
@@ -143,8 +143,7 @@ defmodule ElixirScript.Translate.Forms.Remote do
   def process_module_name(module, state) when is_atom(module) do
     cond do
       ElixirScript.Translate.Module.is_js_module(module, state) ->
-        members = tl(Module.split(module))
-        Identifier.make_namespace_members(members)
+        process_js_module_name(module, state)
       module === Elixir ->
         members = ["Elixir", "__load"]
 
@@ -168,6 +167,23 @@ defmodule ElixirScript.Translate.Forms.Remote do
     Form.compile!(module, state)
   end
 
+  defp process_js_module_name(module, state) do
+    case Module.split(module) do
+      ["JS"] ->
+        J.member_expression(
+          J.member_expression(
+            J.identifier("Bootstrap"),
+            J.identifier("Core")
+          ),
+          J.identifier("global")
+        )
+      ["JS" | rest] ->
+        Identifier.make_namespace_members(rest)
+      x ->
+        Identifier.make_namespace_members(x)         
+    end
+  end
+
   defp erlang_compat_function(module, function) do
     J.member_expression(
       J.member_expression(
diff --git a/lib/elixir_script/next/passes/translate/module.ex b/lib/elixir_script/next/passes/translate/module.ex
@@ -57,7 +57,7 @@ defmodule ElixirScript.Translate.Module do
     # any public functions
     case exports do
       %ESTree.ObjectExpression{ properties: [] } ->
-        ModuleState.put_module(pid, module, Map.put(info, :js_ast, J.program([])))
+        nil
       _ ->
         { compiled_functions, _ } = Enum.map_reduce(combined_defs, state, &Function.compile(&1, &2))
         
diff --git a/lib/elixir_script/next/passes/translate/module_state.ex b/lib/elixir_script/next/passes/translate/module_state.ex
diff --git a/priv/std_lib/string.ex b/priv/std_lib/string.ex
@@ -199,6 +199,11 @@ defmodule ElixirScript.String do
   end
 
   def valid_character?(codepoint) do
-    ElixirScript.Bootstrap.Functions.is_valid_character(codepoint)
+    try do
+      JS.String.fromCodePoint(codepoint) != nil
+    rescue
+      _ ->
+        false
+    end
   end
 end
