elixirscript
diff --git a/‎lib/elixir_script/passes/translate/form.ex‎
Lines changed: 80 additions & 0 deletions b/‎lib/elixir_script/passes/translate/form.ex‎
Lines changed: 80 additions & 0 deletions
diff --git a/‎lib/elixir_script/passes/translate/forms/remote.ex‎
Lines changed: 0 additions & 70 deletions b/‎lib/elixir_script/passes/translate/forms/remote.ex‎
Lines changed: 0 additions & 70 deletions
@@ -211,6 +211,86 @@ defmodule ElixirScript.Translate.Form do
     ElixirScript.Translate.Function.compile(ast, state)
   end
 
+  def compile({{:., _, [:erlang, op]}, _, [item]}, state) when op in [:+, :-] do
+    ast = J.unary_expression(
+      op,
+      true,
+      compile!(item, state)
+    )
+
+    {ast, state}
+  end
+
+  def compile({{:., _, [:erlang, op]}, _, [left, right]}, state) when op in [:+, :-, :*, :/, :==, :>, :<, :>=] do
+    ast = J.binary_expression(
+      op,
+      compile!(left, state),
+      compile!(right, state)
+    )
+
+    {ast, state}
+  end
+
+  def compile({{:., _, [:erlang, :"=<"]}, _, [left, right]}, state) do
+    ast = J.binary_expression(
+      :<=,
+      compile!(left, state),
+      compile!(right, state)
+    )
+
+    {ast, state}
+  end
+
+  def compile({{:., _, [:erlang, :"=:="]}, _, [left, right]}, state) do
+    ast = J.binary_expression(
+      :===,
+      compile!(left, state),
+      compile!(right, state)
+    )
+
+    {ast, state}
+  end
+
+  def compile({{:., _, [:erlang, :"=/="]}, _, [left, right]}, state) do
+    ast = J.binary_expression(
+      :!==,
+      compile!(left, state),
+      compile!(right, state)
+    )
+
+    {ast, state}
+  end
+
+  def compile({{:., _, [:erlang, :"/="]}, _, [left, right]}, state) do
+    ast = J.binary_expression(
+      :!=,
+      compile!(left, state),
+      compile!(right, state)
+    )
+
+    {ast, state}
+  end
+
+  def compile({{:., _, [:erlang, op]}, _, [left, right]}, state) when op in [:andalso, :and] do
+    ast = J.binary_expression(
+      :&&,
+      compile!(left, state),
+      compile!(right, state)
+    )
+
+    {ast, state}
+  end
+
+  def compile({{:., _, [:erlang, op]}, _, [left, right]}, state) when op in [:orelse, :or] do
+    ast = J.binary_expression(
+      :||,
+      compile!(left, state),
+      compile!(right, state)
+    )
+
+    {ast, state}
+  end
+
   def compile({{:., _, [{_, _, nil} = var, func_or_prop]}, _, []}, state) do
     ast = J.call_expression(
       ElixirScript.Translate.Forms.JS.call_property(),
 
@@ -27,76 +27,6 @@ defmodule ElixirScript.Translate.Forms.Remote do
   erlang functions into JavaScript functions.
   """
 
-  def compile({:., _, [:erlang, :+]}, state) do
-    ast = erlang_compat_function("erlang", "plus")
-    { ast, state }
-  end
-
-  def compile({:., _, [:erlang, :-]}, state) do
-    ast = erlang_compat_function("erlang", "minus")
-    { ast, state }
-  end
-
-  def compile({:., _, [:erlang, :*]}, state) do
-    ast = erlang_compat_function("erlang", "multiply")
-    { ast, state }
-  end
-
-  def compile({:., _, [:erlang, :/]}, state) do
-    ast = erlang_compat_function("erlang", "div")
-    { ast, state }
-  end
-
-  def compile({:., _, [:erlang, :==]}, state) do
-    ast = erlang_compat_function("erlang", "equal")
-    { ast, state }
-  end
-
-  def compile({:., _, [:erlang, :>]}, state) do
-    ast = erlang_compat_function("erlang", "greaterThan")
-    { ast, state }
-  end
-
-  def compile({:., _, [:erlang, :>=]}, state) do
-    ast = erlang_compat_function("erlang", "greaterThanOrEqualTo")
-    { ast, state }
-  end
-
-  def compile({:., _, [:erlang, :"/="]}, state) do
-    ast = erlang_compat_function("erlang", "doesNotEqual")
-    { ast, state }
-  end
-
-  def compile({:., _, [:erlang, :"<"]}, state) do
-    ast = erlang_compat_function("erlang", "lessThan")
-    { ast, state }
-  end
-
-  def compile({:., _, [:erlang, :"=<"]}, state) do
-    ast = erlang_compat_function("erlang", "lessThanOrEqualTo")
-    { ast, state }
-  end
-
-  def compile({:., _, [:erlang, :"=:="]}, state) do
-    ast = erlang_compat_function("erlang", "strictlyEqual")
-    { ast, state }
-  end
-
-  def compile({:., _, [:erlang, :"=/="]}, state) do
-    ast = erlang_compat_function("erlang", "doesNotStrictlyEqual")
-    { ast, state }
-  end
-
-  def compile({:., _, [:erlang, function]}, state) when function in [:andalso, :and] do
-    ast = erlang_compat_function("erlang", "and")
-    { ast, state }
-  end
-
-  def compile({:., _, [:erlang, function]}, state) when function in [:orelse, :or] do
-    ast = erlang_compat_function("erlang", "or")
-    { ast, state }
-  end
-
   def compile({:., _, [:erlang, :++]}, state) do
     ast = erlang_compat_function("erlang", "list_concatenation")
     { ast, state }