Make receive a runtime error. Add warning when receive is encountered. Refactor how functions are implemented

bryanjos · bryanjos · commit cd9001d09875 · 2017-05-29T16:25:02.000-05:00
diff --git a/Supported.md b/Supported.md
diff --git a/lib/elixir_script/gen/supported.ex b/lib/elixir_script/gen/supported.ex
diff --git a/lib/elixir_script/next/compiler.ex b/lib/elixir_script/next/compiler.ex
@@ -32,7 +32,6 @@ defmodule ElixirScript.Compiler do
     |> Map.put(:entry_modules, entry_modules)
 
     options = default_options
-    IO.inspect options
     Map.put(options, :module_formatter, get_module_formatter(options[:format]))
   end
 
diff --git a/lib/elixir_script/next/passes/translate/clause.ex b/lib/elixir_script/next/passes/translate/clause.ex
@@ -90,7 +90,7 @@ defmodule ElixirScript.Translate.Clause do
     [J.return_statement(J.identifier("null"))]
   end
 
-  defp compile_guard(params, guards, state) do
+  def compile_guard(params, guards, state) do
 
     guards = guards
     |> List.wrap
diff --git a/lib/elixir_script/next/passes/translate/examples/example.ex b/lib/elixir_script/next/passes/translate/examples/example.ex
@@ -1,6 +1,16 @@
 defmodule Example do
   def start(_, _) do
-   1 + 1
+receive do
+  {:selector, i, value} when is_integer(i) ->
+    value
+  value when is_atom(value) ->
+    value
+  _ ->
+    IO.puts :stderr, "Unexpected message received"
+after
+  5000 ->
+    IO.puts :stderr, "No message in 5 seconds"
+end
   end
 
 end
diff --git a/lib/elixir_script/next/passes/translate/form.ex b/lib/elixir_script/next/passes/translate/form.ex
@@ -1,9 +1,10 @@
 defmodule ElixirScript.Translate.Form do
   alias ESTree.Tools.Builder, as: J
-  alias ElixirScript.Translate.Forms.{Bitstring, Match, Call, Try, For, Struct}
+  alias ElixirScript.Translate.Forms.{Bitstring, Match, Call, Try, For, Struct, Receive}
   alias ElixirScript.Translate.Functions.{Erlang, Lists, Maps}
   alias ElixirScript.Translator.Identifier
   alias ElixirScript.Translate.Clause
+  require Logger
 
   @erlang_modules [
     :erlang,
@@ -133,9 +134,11 @@ defmodule ElixirScript.Translate.Form do
     )
   end
 
-  def compile({:receive, context, _}, _state) do
+  def compile({:receive, context, [blocks]}, state) do
     line = Keyword.get(context, :line, 1)
-    raise ElixirScript.CompileError, message: "Line: #{line} receive not supported"
+    {function, arity} = Map.get(state, :function)
+    Logger.warn "receive not supported, Module: #{inspect state.module}, Function: #{function}/#{arity}, Line: #{line}"
+    Receive.compile(blocks, state)
   end
 
   def compile({:try, _, [blocks]}, state) do
diff --git a/lib/elixir_script/next/passes/translate/forms/receive.ex b/lib/elixir_script/next/passes/translate/forms/receive.ex
@@ -0,0 +1,26 @@
+defmodule ElixirScript.Translate.Forms.Receive do
+  @moduledoc false
+  alias ESTree.Tools.Builder, as: J
+
+  def compile(blocks, state) do
+    receive_block = Keyword.get(blocks, :do)
+    after_block = Keyword.get(blocks, :after, nil)
+
+    receive_function = J.member_expression(
+      J.member_expression(
+        J.identifier("Bootstrap"),
+        J.member_expression(
+          J.identifier("Core"),
+          J.identifier("SpecialForms")
+        )
+      ),
+      J.identifier("receive")
+    )
+
+    J.call_expression(
+      receive_function,
+      []
+    )
+
+  end
+end
diff --git a/lib/elixir_script/next/passes/translate/function.ex b/lib/elixir_script/next/passes/translate/function.ex
@@ -1,6 +1,8 @@
 defmodule ElixirScript.Translate.Function do
   alias ESTree.Tools.Builder, as: J
   alias ElixirScript.Translate.Clause
+  alias ElixirScript.Translate.Forms.Pattern
+  alias ElixirScript.Translate.Form
 
   @moduledoc """
   Translates the given Elixir function AST into the
@@ -20,18 +22,108 @@ defmodule ElixirScript.Translate.Function do
 
   def compile({{name, arity}, type, _, clauses}, state) do
     state = Map.put(state, :function, {name, arity})
+    clauses = compile_clauses(clauses, state)
+
+    arg_matches_declarator = J.variable_declarator(
+      J.identifier("__arg_matches__"),
+      J.identifier("null")
+    )
+
+    arg_matches_declaration = J.variable_declaration([arg_matches_declarator], :let)
 
     declarator = J.variable_declarator(
       ElixirScript.Translator.Identifier.make_function_name(name, arity),
-      J.call_expression(
+      J.function_expression(
+                [J.rest_element(J.identifier("__function_args__"))],
+                [],
+                J.block_statement([
+                  arg_matches_declaration,
+                  clauses,
+                  J.throw_statement(
+                    J.call_expression(
+                      J.member_expression(
+                        patterns_ast(),
+                        J.identifier("MatchError")
+                      ),
+                      [J.identifier("__function_args__")]
+                    )
+                  )
+                ])
+              )
+    )
+
+    J.variable_declaration([declarator], :const)
+  end
+
+  defp compile_clauses(clauses, state) do
+    clauses
+    |> Enum.map(&compile_clause(&1, state))
+    |> Enum.map(fn {patterns, params, guards, body} ->
+      IO.inspect guards
+      match_or_default_call = J.call_expression(
         J.member_expression(
           patterns_ast(),
-          J.identifier("defmatch")
+          J.identifier("match_or_default")
+        ),
+        [J.array_expression(patterns), J.identifier("__function_args__"), guards]
+      )
+
+      J.if_statement(
+        J.binary_expression(
+          :!==,
+          J.assignment_expression(:=, J.identifier("__arg_matches__"), match_or_default_call),
+          J.identifier("null")
         ),
-        Enum.map(clauses, &Clause.compile(&1, state))
+        J.block_statement(body)
       )
+    end)
+    |> Enum.reverse
+    |> Enum.reduce(nil, fn 
+      if_ast, nil ->
+        if_ast
+      if_ast, ast ->
+        %{if_ast | alternate: ast}
+    end)
+  end
+
+  defp compile_clause({ _, args, guards, body}, state) do
+    {patterns, params} = Pattern.compile(args, state)
+    guard = Clause.compile_guard(params, guards, state)
+
+    body = case body do
+      nil ->
+        J.identifier("null")
+      {:__block__, _, block_body} ->
+        Enum.map(block_body, &Form.compile(&1, state))
+        |> List.flatten
+      b when is_list(b) ->
+        Enum.map(b, &Form.compile(&1, state))
+        |> List.flatten
+      _ ->
+        Form.compile(body, state)
+    end
+
+    body = Clause.return_last_statement(body)
+
+    declarator = J.variable_declarator(
+      J.array_expression(params),
+      J.identifier("__arg_matches__")
     )
 
-    J.variable_declaration([declarator], :const)
+    declaration = J.variable_declaration([declarator], :const)
+
+    body = [declaration] ++ body
+    {patterns, params, guard, body}
+  end
+
+  defp compile_clause({:->, _, [[{:when, _, params}], body ]}, state) do
+    guards = List.last(params)
+    params = params |> Enum.reverse |> tl |> Enum.reverse
+
+    compile_clause({[], params, guards, body}, state)
+  end
+
+  defp compile_clause({:->, _, [params, body]}, state) do
+    compile_clause({[], params, [], body}, state)
   end
 end
diff --git a/lib/elixir_script/next/passes/translate/module.ex b/lib/elixir_script/next/passes/translate/module.ex
@@ -26,6 +26,7 @@ defmodule ElixirScript.Translate.Module do
     } = info
 
     state = %{
+      module: module,
       pid: pid
     }
  
diff --git a/src/javascript/lib/core/special_forms.js b/src/javascript/lib/core/special_forms.js

Original file line number	Diff line number	Diff line change
`@@ -26,6 +26,7 @@ defmodule ElixirScript.Translate.Module do`
`26`	`26`	`} = info`
`27`	`27`
`28`	`28`	`state = %{`
	`29`	`+ module: module,`
`29`	`30`	`pid: pid`
`30`	`31`	`}`
`31`	`32`