Fix used module reference bugs

bryanjos · bryanjos · commit e2348b2ae48d · 2018-01-20T10:10:38.000-06:00
diff --git a/lib/elixir_script/passes/find_used_modules.ex b/lib/elixir_script/passes/find_used_modules.ex
@@ -133,7 +133,9 @@ defmodule ElixirScript.FindUsedModules do
     Enum.each(clauses, &walk(&1, state))
   end
 
-  defp walk({_, _args, _guards, body}, state) do
+  defp walk({_, args, guards, body}, state) do
+    walk(args, state)
+    walk(guards, state)
     walk_block(body, state)
   end
 
diff --git a/lib/elixir_script/passes/output.ex b/lib/elixir_script/passes/output.ex
@@ -33,7 +33,7 @@ defmodule ElixirScript.Output do
   defp filter_used_modules(used_modules, pid) do
     used_modules
     |> Enum.filter(fn module ->
-      ModuleState.is_global_module(pid, module) == false
+      module in ModuleState.list_javascript_modules(pid) == false
     end)
   end
 
diff --git a/lib/elixir_script/passes/translate/forms/remote.ex b/lib/elixir_script/passes/translate/forms/remote.ex
@@ -33,7 +33,7 @@ defmodule ElixirScript.Translate.Forms.Remote do
     :orddict,
     :filelib,
     :net_adm,
-    :net_kernel,
+    :net_kernel
   ]
 
   @doc """
@@ -46,31 +46,32 @@ defmodule ElixirScript.Translate.Forms.Remote do
 
   def compile({:., _, [:erlang, :++]}, state) do
     ast = erlang_compat_function("erlang", "list_concatenation")
-    { ast, state }
+    {ast, state}
   end
 
   def compile({:., _, [:erlang, :--]}, state) do
     ast = erlang_compat_function("erlang", "list_substraction")
-    { ast, state }
+    {ast, state}
   end
 
   def compile({:., _, [:erlang, :"=<"]}, state) do
     ast = erlang_compat_function("erlang", "lessThanEqualTo")
-    { ast, state }
+    {ast, state}
   end
 
   def compile({:., _, [:erlang, :+]}, state) do
     ast = erlang_compat_function("erlang", "add")
-    { ast, state }
+    {ast, state}
   end
 
   def compile({:., _, [module, function]}, state) when module in @erlang_modules do
-    ast = J.member_expression(
-      Helpers.core_module(module),
-      J.identifier(function)
-    )
+    ast =
+      J.member_expression(
+        Helpers.core_module(module),
+        J.identifier(function)
+      )
 
-    { ast, state }
+    {ast, state}
   end
 
   def compile({:., _, [function_name]}, state) do
@@ -80,30 +81,39 @@ defmodule ElixirScript.Translate.Forms.Remote do
   def compile({:., _, [module, function]}, state) do
     function_name = ElixirScript.Translate.Identifier.make_function_name(function)
 
-    ast = J.member_expression(
-      process_module_name(module, state),
-      function_name
-    )
+    ast =
+      J.member_expression(
+        process_module_name(module, state),
+        function_name
+      )
 
     {ast, state}
   end
 
   def process_module_name(module, state) when is_atom(module) do
     cond do
+      ElixirScript.Translate.Module.is_js_module(module, state) and
+          ModuleState.is_global_module(state.pid, module) ->
+        ElixirScript.Translate.Identifier.make_alias(Module.split(module) |> Enum.reverse())
+
       ElixirScript.Translate.Module.is_js_module(module, state) ->
         process_js_module_name(module, state)
+
       module === Elixir ->
         module
         |> ElixirScript.Output.module_to_name()
-        |> J.identifier
+        |> J.identifier()
+
       module === :ElixirScript ->
         module
         |> ElixirScript.Output.module_to_name()
-        |> J.identifier
+        |> J.identifier()
+
       ElixirScript.Translate.Module.is_elixir_module(module) ->
         module
         |> ElixirScript.Output.module_to_name()
-        |> J.identifier
+        |> J.identifier()
+
       true ->
         ElixirScript.Translate.Identifier.make_identifier(module)
     end
@@ -117,12 +127,14 @@ defmodule ElixirScript.Translate.Forms.Remote do
     case ModuleState.get_js_module_name(state.pid, module) do
       name when is_binary(name) ->
         J.identifier(name)
+
       name when is_atom(name) ->
         case to_string(name) do
           "Elixir." <> _ ->
             module
             |> ElixirScript.Output.module_to_name()
-            |> J.identifier
+            |> J.identifier()
+
           x ->
             J.identifier(x)
         end
diff --git a/lib/elixir_script/passes/translate/identifier.ex b/lib/elixir_script/passes/translate/identifier.ex
@@ -38,7 +38,7 @@ defmodule ElixirScript.Translate.Identifier do
   def make_identifier(ast) do
     ast
     |> filter_name
-    |> J.identifier
+    |> J.identifier()
   end
 
   def filter_name(reserved_word) when reserved_word in @js_reserved_words do
@@ -57,22 +57,23 @@ defmodule ElixirScript.Translate.Identifier do
     end
   end
 
-  defp make_alias([x]) do
+  def make_alias([x]) do
     make_identifier(x)
   end
 
-  defp make_alias([h|t]) do
+  def make_alias([h | t]) do
     J.member_expression(make_alias(t), make_identifier(h))
   end
 
   def make_namespace_members(module_name) do
     case module_name do
       m when is_list(m) ->
         m
+
       m when is_atom(m) ->
         Module.split(m)
     end
-    |> Enum.reverse
+    |> Enum.reverse()
     |> make_alias
   end
 
@@ -84,5 +85,4 @@ defmodule ElixirScript.Translate.Identifier do
   def js_reserved_words() do
     @js_reserved_words
   end
-
 end
diff --git a/lib/elixir_script/state.ex b/lib/elixir_script/state.ex
@@ -115,7 +115,8 @@ defmodule ElixirScript.State do
 
   def is_global_module(pid, module) do
     Agent.get(pid, fn state ->
-      result = Enum.find(state.js_modules, fn {mod, _, _} -> mod == module end)
+      result =
+        Enum.find(state.js_modules, fn {mod, _name, path} -> mod == module and path == nil end)
 
       if result == nil, do: false, else: true
     end)
