Remove a bunch of warnings

bryanjos · bryanjos · commit 20f893dd61ff · 2017-07-04T15:47:53.000-05:00
diff --git a/lib/elixir_script/cli.ex b/lib/elixir_script/cli.ex
@@ -54,7 +54,7 @@ defmodule ElixirScript.CLI do
   end
 
   def process(:help) do
-    IO.write help_message
+    IO.write help_message()
   end
 
   def process(:version) do
@@ -101,7 +101,7 @@ defmodule ElixirScript.CLI do
   end
 
   defp handle_input(input) do
-    input = input
+    input
     |> Enum.map(fn(x) -> String.split(x, [" ", ","], trim: true) end)
     |> List.flatten
     |> Enum.map(fn(x) -> Module.concat([x]) end)
diff --git a/lib/elixir_script/module_systems/common.ex b/lib/elixir_script/module_systems/common.ex
@@ -1,8 +1,6 @@
 defmodule ElixirScript.ModuleSystems.Common do
   @moduledoc false
   alias ESTree.Tools.Builder, as: JS
-  alias ElixirScript.Translator
-  alias ElixirScript.Translator.{State, Utils}
 
   def build(imports, js_imports, body, exports) do
     module_imports = Enum.map(imports, fn {module, path} -> import_module(module, path) end)
diff --git a/lib/elixir_script/module_systems/namespace.ex b/lib/elixir_script/module_systems/namespace.ex
@@ -3,7 +3,7 @@ defmodule ElixirScript.ModuleSystems.Namespace do
   alias ESTree.Tools.Builder, as: JS
   alias ElixirScript.Translate.Identifier
 
-  def build(module_name, body, exports, env) do
+  def build(module_name, body, exports) do
     List.wrap(make_namespace_body(module_name, body, exports))
   end
 
@@ -28,7 +28,7 @@ defmodule ElixirScript.ModuleSystems.Namespace do
   defp make_namespace_body(module_name, body, exports) do
     values = module_name_function_call(module_name, "__exports")
 
-    _if = JS.if_statement(
+    js_if = JS.if_statement(
       values,
       JS.return_statement(values)
     )
@@ -62,7 +62,7 @@ defmodule ElixirScript.ModuleSystems.Namespace do
           JS.identifier("__load")
     )
 
-    func_body = JS.block_statement([_if] ++ body ++ [declaration, assign] ++ exports)
+    func_body = JS.block_statement([js_if] ++ body ++ [declaration, assign] ++ exports)
 
     func = JS.function_expression([JS.identifier("Elixir")], [], func_body)
     JS.assignment_expression(
diff --git a/lib/elixir_script/passes/find_used_functions.ex b/lib/elixir_script/passes/find_used_functions.ex
@@ -98,7 +98,7 @@ defmodule ElixirScript.FindUsedFunctions do
     walk(tail, state)
   end
 
-  defp walk({:::, _, _}, state) do
+  defp walk({:::, _, _}, _) do
     nil
   end
 
diff --git a/lib/elixir_script/passes/find_used_modules.ex b/lib/elixir_script/passes/find_used_modules.ex
@@ -95,7 +95,7 @@ defmodule ElixirScript.FindUsedModules do
     walk(tail, state)
   end
 
-  defp walk({:::, _, _}, state) do
+  defp walk({:::, _, _}, _) do
     nil
   end
 
@@ -232,7 +232,7 @@ defmodule ElixirScript.FindUsedModules do
     walk({function, [], params}, state)
   end
 
-  defp walk({:., _, [JS, _]}, state) do
+  defp walk({:., _, [JS, _]}, _) do
     nil
   end
 
diff --git a/lib/elixir_script/passes/output.ex b/lib/elixir_script/passes/output.ex
@@ -10,8 +10,9 @@ defmodule ElixirScript.Output do
   """
   @spec execute([atom], pid) :: nil
   def execute(modules, pid) do
-    modules = Enum.filter_map(modules, fn {_, info} -> Map.has_key?(info, :js_ast) end,
-      fn {_module, info} ->
+    modules = modules
+    |> Enum.filter(fn {_, info} -> Map.has_key?(info, :js_ast) end)
+    |> Enum.map(fn {_module, info} ->
         info.js_ast
       end
     )
diff --git a/lib/elixir_script/passes/output/js_module.ex b/lib/elixir_script/passes/output/js_module.ex
@@ -12,14 +12,14 @@ defmodule ElixirScript.Output.JSModule do
     elixir = J.variable_declaration([declarator], :const)
 
     table_additions = Enum.map(opts.js_modules, fn
-      {module, path} -> add_import_to_table(module)
-      {module, path, _} -> add_import_to_table(module)
+      {module, _} -> add_import_to_table(module)
+      {module, _, _} -> add_import_to_table(module)
     end)
 
     ast = opts.module_formatter.build(
       [],
       opts.js_modules,
-      [elixir, create_atom_table(), start, load] ++ table_additions ++ body,
+      [elixir, create_atom_table(), start(), load()] ++ table_additions ++ body,
       J.identifier("Elixir")
     )
 
diff --git a/lib/elixir_script/passes/translate.ex b/lib/elixir_script/passes/translate.ex
@@ -1,9 +1,6 @@
 defmodule ElixirScript.Translate do
   @moduledoc false
 
-  alias ElixirScript.State, as: ModuleState
-  alias ESTree.Tools.{Builder, Generator}
-
   @doc """
   Takes a list of modules and translates their ast into
   JavaScript AST. The modules are the ones collected from
diff --git a/lib/elixir_script/passes/translate/form.ex b/lib/elixir_script/passes/translate/form.ex
@@ -1,8 +1,7 @@
 defmodule ElixirScript.Translate.Form do
   alias ESTree.Tools.Builder, as: J
   alias ElixirScript.Translate.Forms.{Bitstring, Match, Try, For, Receive, Remote, Pattern}
-  alias ElixirScript.Translate.Functions.{Erlang, Lists, Maps}
-  alias ElixirScript.Translate.{Identifier, Clause}
+  alias ElixirScript.Translate.Clause
   require Logger
 
   @moduledoc """
@@ -178,7 +177,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)
+    {function, _arity} = Map.get(state, :function)
     Logger.warn fn() ->
       "receive not supported, Module: #{inspect state.module}, Function: #{function}, Line: #{line}"
     end
@@ -201,7 +200,7 @@ defmodule ElixirScript.Translate.Form do
     Remote.compile(ast, state)
   end
 
-  def compile({:super, context, params}, state) when is_list(params) do
+  def compile({:super, _, params}, state) when is_list(params) do
     {function_name, _} = Map.get(state, :function)
     {var_decs, params} = compile_params(params, state)
 
@@ -259,7 +258,7 @@ defmodule ElixirScript.Translate.Form do
     end
   end
 
-  def compile({var, _, _} = ast, state) do
+  def compile({var, _, _}, state) do
     var = Pattern.get_variable_name(to_string(var), state)
     { ElixirScript.Translate.Identifier.make_identifier(var), state }
   end
diff --git a/lib/elixir_script/passes/translate/forms/bitstring.ex b/lib/elixir_script/passes/translate/forms/bitstring.ex
@@ -98,7 +98,7 @@ defmodule ElixirScript.Translate.Forms.Bitstring do
   defp do_compile_element({type, ast}) do
     JS.call_expression(
       JS.member_expression(
-        bitstring_class,
+        bitstring_class(),
         JS.identifier(type)
       ),
       [
@@ -110,7 +110,7 @@ defmodule ElixirScript.Translate.Forms.Bitstring do
   defp do_compile_element({type, ast, params}) when is_list(params) do
     JS.call_expression(
       JS.member_expression(
-        bitstring_class,
+        bitstring_class(),
         JS.identifier(type)
       ),
       [
diff --git a/lib/elixir_script/passes/translate/forms/for.ex b/lib/elixir_script/passes/translate/forms/for.ex
@@ -51,7 +51,7 @@ defmodule ElixirScript.Translate.Forms.For do
     {ast, state}
   end
 
-  defp handle_args(nil, module_state) do
+  defp handle_args(nil, _) do
     %{generators: [], args: [], filter: nil, fun: nil, into: nil, patterns: []}
   end
 
@@ -123,7 +123,7 @@ defmodule ElixirScript.Translate.Forms.For do
 
 
   defp create_function_expression(ast, state, module_state) do
-    { ast, module_state } = Enum.map_reduce(List.wrap(ast), module_state, fn x, acc_state ->
+    { ast, _ } = Enum.map_reduce(List.wrap(ast), module_state, fn x, acc_state ->
        Form.compile(x, acc_state)
     end)
 
diff --git a/lib/elixir_script/passes/translate/forms/js.ex b/lib/elixir_script/passes/translate/forms/js.ex
@@ -42,7 +42,7 @@ defmodule ElixirScript.Translate.Forms.JS do
     params = case params do
       p when is_list(p) ->
         Enum.map(params, &Form.compile!(&1, state))
-      p ->
+      _ ->
         [J.rest_element(Form.compile!(params, state))]
     end
 
diff --git a/lib/elixir_script/passes/translate/forms/match.ex b/lib/elixir_script/passes/translate/forms/match.ex
@@ -38,7 +38,7 @@ defmodule ElixirScript.Translate.Forms.Match do
 
     js_ast = case left do
       list when is_list(list) ->
-        make_list_ref(array_pattern, params, state)
+        make_list_ref(array_pattern, params)
       { _, _ } ->
         make_tuple_ref(array_pattern, params)
       {:{}, _, _ } ->
@@ -58,7 +58,7 @@ defmodule ElixirScript.Translate.Forms.Match do
   end
 
 
-  defp make_list_ref(array_pattern, params, state) do
+  defp make_list_ref(array_pattern, params) do
     {ref, params} = make_params(params)
 
     ref_declarator = J.variable_declarator(ref, J.array_expression(params))
diff --git a/lib/elixir_script/passes/translate/forms/remote.ex b/lib/elixir_script/passes/translate/forms/remote.ex
@@ -166,7 +166,7 @@ defmodule ElixirScript.Translate.Forms.Remote do
     Form.compile!(module, state)
   end
 
-  defp process_js_module_name(module, state) do
+  defp process_js_module_name(module, _) do
     case Module.split(module) do
       ["JS"] ->
         J.member_expression(
diff --git a/lib/elixir_script/passes/translate/forms/try.ex b/lib/elixir_script/passes/translate/forms/try.ex
@@ -64,7 +64,7 @@ defmodule ElixirScript.Translate.Forms.Try do
 
   defp process_rescue_block(rescue_block, state) do
     processed_clauses = Enum.map(rescue_block, fn
-      {:->, _, [ [{:in, _, [param, names]} = pattern], body]} ->
+      {:->, _, [ [{:in, _, [param, names]}], body]} ->
         {ast, _} = Clause.compile({[], [param], [{{:., [], [Enum, :member?]}, [], [param, names]}], body}, state)
         ast
       {:->, _, [ [param], body]} ->
@@ -91,7 +91,7 @@ defmodule ElixirScript.Translate.Forms.Try do
   end
 
   defp prepare_function_body(body, state) do
-    {ast, state} = Function.compile_block(body, state)
+    {ast, _} = Function.compile_block(body, state)
 
     Clause.return_last_statement(ast)
   end
diff --git a/lib/elixir_script/passes/translate/function.ex b/lib/elixir_script/passes/translate/function.ex
@@ -92,7 +92,7 @@ defmodule ElixirScript.Translate.Function do
   defp compile_clauses(clauses, state) do
     clauses
     |> Enum.map(&compile_clause(&1, state))
-    |> Enum.map(fn {patterns, params, guards, body} ->
+    |> Enum.map(fn {patterns, _params, guards, body} ->
       match_or_default_call = J.call_expression(
         J.member_expression(
           patterns_ast(),
@@ -129,18 +129,7 @@ defmodule ElixirScript.Translate.Function do
     {patterns, params, state} = Pattern.compile(args, state)
     guard = Clause.compile_guard(params, guards, state)
 
-    body = case body do
-      nil ->
-        J.identifier("null")
-      {:__block__, _, block_body} ->
-        {list, _} = Enum.map_reduce(block_body, state, &Form.compile(&1, &2))
-        List.flatten(list)
-      b when is_list(b) ->
-        {list, _} = Enum.map_reduce(b, state, &Form.compile(&1, &2))
-        J.array_expression(list)
-      _ ->
-        Form.compile!(body, state)
-    end
+    {body, _state} = compile_block(body, state)
 
     body = body
     |> Clause.return_last_statement
@@ -174,9 +163,6 @@ defmodule ElixirScript.Translate.Function do
       {:__block__, _, block_body} ->
         {list, _} = Enum.map_reduce(block_body, state, &Form.compile(&1, &2))
         List.flatten(list)
-      b when is_list(b) ->
-        {list, _} = Enum.map_reduce(b, state, &Form.compile(&1, &2))
-        List.flatten(list)
       _ ->
         Form.compile!(block, state)
     end
diff --git a/lib/elixir_script/passes/translate/module.ex b/lib/elixir_script/passes/translate/module.ex
@@ -62,8 +62,7 @@ defmodule ElixirScript.Translate.Module do
         js_ast = ElixirScript.ModuleSystems.Namespace.build(
           module,
           compiled_functions,
-          exports,
-          nil
+          exports
         )
 
         ModuleState.put_module(pid, module, Map.put(info, :js_ast, hd(js_ast)))
diff --git a/lib/elixir_script/passes/translate/protocol.ex b/lib/elixir_script/passes/translate/protocol.ex
@@ -1,7 +1,7 @@
 defmodule ElixirScript.Translate.Protocol do
   @moduledoc false
   alias ESTree.Tools.Builder, as: J
-  alias ElixirScript.Translate.{Function, Form, Identifier}
+  alias ElixirScript.Translate.{Function, Identifier}
   alias ElixirScript.State, as: ModuleState
 
 
@@ -34,21 +34,20 @@ defmodule ElixirScript.Translate.Protocol do
 
     declaration = J.variable_declaration([declarator], :const)
 
-    body = build_implementations(impls, pid)
+    body = build_implementations(impls)
 
     body = [declaration] ++ body
 
     js_ast = ElixirScript.ModuleSystems.Namespace.build(
       module,
       body,
-      J.identifier("protocol"),
-      nil
+      J.identifier("protocol")
     )
 
     ModuleState.put_module(pid, module, Map.put(info, :js_ast, hd(js_ast)))
   end
 
-  defp build_implementations(impls, pid) do
+  defp build_implementations(impls) do
     Enum.map(impls, fn({impl, impl_for}) ->
       members = ["Elixir"] ++ Module.split(impl) ++ ["__load"]
 
@@ -165,7 +164,7 @@ defmodule ElixirScript.Translate.Protocol do
     case Module.split(module) do
       ["JS" | rest] ->
         Identifier.make_namespace_members(rest)
-      split_module ->
+      _ ->
         J.call_expression(
           J.member_expression(
             J.identifier("Symbol"),
diff --git a/lib/elixir_script/watcher.ex b/lib/elixir_script/watcher.ex
@@ -22,7 +22,7 @@ defmodule ElixirScript.Watcher do
   def handle_info({_pid, {:fs, :file_event}, {path, event}}, state) do
 
     try do
-      if input_changed?(to_string(path), state) do
+      if input_changed?(to_string(path)) do
         Logger.debug fn() ->
           "Event: #{inspect event} Path: #{path}"
         end
@@ -36,7 +36,7 @@ defmodule ElixirScript.Watcher do
     {:noreply, state}
   end
 
-  defp input_changed?(path, state) do
+  defp input_changed?(path) do
     case Path.extname(path) do
       ".beam" ->
         true
diff --git a/lib/mix/tasks/compile.elixir_script.ex b/lib/mix/tasks/compile.elixir_script.ex
@@ -37,23 +37,17 @@ defmodule Mix.Tasks.Compile.ElixirScript do
 
   @spec run(any()) :: :ok
   def run(_) do
-    elixirscript_base = Path.join([Mix.Project.build_path, "elixirscript"])
-    do_compile(elixirscript_base, Mix.Project.config[:app])
+    do_compile()
     :ok
   end
 
-  defp do_compile(_, nil) do
-    raise ElixirScript.CompileError, message: "Unable to find mix project app name"
-  end
-
-  defp do_compile(elixirscript_base, app) do
-
+  defp do_compile() do
     {input, opts} = get_compiler_params()
     ElixirScript.Compiler.compile(input, opts)
   end
 
   def clean do
-    {input, opts} = get_compiler_params()
+    {_, opts} = get_compiler_params()
 
     case opts[:output] do
       path when is_binary(path) ->
@@ -78,7 +72,6 @@ defmodule Mix.Tasks.Compile.ElixirScript do
     {input, opts}
   end
 
-
   defp get_elixirscript_config() do
     config  = Mix.Project.config
     exjs_config = cond do
