gets threaded erroring working

lib/zig/_module.ex

@@ -221,7 +221,7 @@ defmodule Zig.Module do
       if Enum.any?(module.nifs, &match?(%Error{}, &1.return.type)) do
         quote do
           require Zig.Manifest
-          Zig.Manifest.resolver(unquote(module.manifest), unquote(module.module_code_path), :defp)
+          Zig.Manifest.resolver(unquote(module.manifest), unquote(module.zig_code_path), :defp)
         end
       end
 

lib/zig/_nif.ex

@@ -93,17 +93,18 @@ defmodule Zig.Nif do
   based on nif options for this function keyword at (opts :: nifs :: function_name)
   """
   def new(name, file, opts!) do
-    opts! = adjust(opts!) 
+    opts! = adjust(opts!)
+
     %__MODULE__{
       name: name,
       file: file,
       export: Keyword.get(opts!, :export, true),
       concurrency: Map.get(@concurrency_modules, opts![:concurrency], Synchronous)
-    } 
+    }
   end
 
   def adjust(opts) do
-    Enum.map(opts, fn 
+    Enum.map(opts, fn
       concurrency when concurrency in @concurrency_opts -> {:concurrency, concurrency}
       {atom, _} = kv when is_atom(atom) -> atom
     end)
@@ -221,7 +222,7 @@ defmodule Zig.Nif do
 
   def maybe_catch(_), do: nil
 
-  def resources(nif),do: nif.concurrency.resources(nif)
+  def resources(nif), do: nif.concurrency.resources(nif)
 
   # COMMON TOOLS
   # generates AST for parameters.  
@@ -241,7 +242,7 @@ defmodule Zig.Nif do
 
   def binding_error(name, arity) do
     "nif for function #{name}/#{arity} not bound"
-  end  
+  end
 
   # Access behaviour guards
   @impl true

lib/zig/error_prong.ex

@@ -71,7 +71,7 @@ defmodule Zig.ErrorProng do
     ]
   end
 
-  def error_return_prong(:elixir, ignored) do
+  def return_error_prong(:elixir, ignored) do
     stacktrace_prep =
       case ignored do
         [] ->
@@ -111,7 +111,7 @@ defmodule Zig.ErrorProng do
     end
   end
 
-  def error_return_prong(:erlang, _) do
+  def return_error_prong(:erlang, _) do
     ["error:{error, Type, _ExtraStacktrace}:Stacktrace -> erlang:raise(error, Type, Stacktrace)"]
   end
 end

lib/zig/nif/_basic.ex

@@ -10,6 +10,7 @@ defmodule Zig.Nif.Basic do
   To understand wrapping logic, see `Zig.Nif.Marshaller`
   """
 
+  alias Zig.ErrorProng
   alias Zig.Nif
   alias Zig.Nif.DirtyCpu
   alias Zig.Nif.DirtyIo
@@ -112,15 +113,15 @@ defmodule Zig.Nif.Basic do
         end
     ]
 
-    argument_error_prong =
+    argument_error_prong = [ErrorProng.argument_error_prong(:elixir, nif.file, nif.line)]
+
+    error_return_prong =
       List.wrap(
-        if true do
-          Zig.ErrorProng.argument_error_prong(:elixir, nif.file, nif.line)
+        if match?(%Zig.Type.Error{}, nif.signature.return) do
+          ErrorProng.return_error_prong(:elixir, [marshal_name])
         end
       )
 
-    error_return_prong = []
-
     error_prongs =
       case {argument_error_prong, error_return_prong} do
         {[], []} -> []

lib/zig/nif/synchronous.ex

@@ -16,7 +16,7 @@ defmodule Zig.Nif.Synchronous do
   @impl true
   def table_entries(nif) do
     nif
-    |> Nif.arities
+    |> Nif.arities()
     |> Enum.map(&{Basic.entrypoint(nif), &1, nif.name, :synchronous})
   end
 

lib/zig/nif/threaded.ex

@@ -10,37 +10,62 @@ defmodule Zig.Nif.Threaded do
   import Zig.QuoteErl
 
   @impl true
-  #def render_elixir(%{raw: raw} = nif) when not is_nil(raw) do
+  # def render_elixir(%{raw: raw} = nif) when not is_nil(raw) do
   #  entrypoints = Enum.map(nif.params, fn arity ->
   #    unused_params = Nif.elixir_parameters(arity, false)
-#
+  #
   #    quote do
   #      unquote(Nif.style(nif))(unquote(nif.name)(unquote_splicing(unused_params))) do
   #        :erlang.nif_error(unquote(error_text(nif, arity)))
   #      end
   #    end
   #  end)
-  #end
+  # end
 
   def render_elixir(%{signature: %{arity: arity}} = nif) do
     used_params_ast = Nif.elixir_parameters(arity, true)
     unused_params_ast = Nif.elixir_parameters(arity, false)
 
     # TODO: marshal parameters (that need to be marshalled) here.
 
-    quote context: Elixir do
-      unquote(Nif.style(nif))(unquote(nif.name)(unquote_splicing(used_params_ast))) do
-        ref = unquote(entrypoint(nif, :launch))(unquote_splicing(used_params_ast))
-
-        receive do
-          {:done, ^ref} ->
-            unquote(entrypoint(nif, :join))(ref)
-
-          {:error, ^ref} ->
-            raise unquote("thread for function #{nif.name} failed during launch")
+    function_code = [
+      do:
+        quote do
+          ref = unquote(entrypoint(nif, :launch))(unquote_splicing(used_params_ast))
+
+          receive do
+            {:done, ^ref} ->
+              unquote(entrypoint(nif, :join))(ref)
+
+            {:error, ^ref} ->
+              raise unquote("thread for function #{nif.name} failed during launch")
+          end
+        end
+    ]
+
+    argument_error_prong = ErrorProng.argument_error_prong(:elixir, nif.file, nif.line)
+
+    error_return_prong =
+      List.wrap(
+        if match?(%Zig.Type.Error{}, nif.signature.return) do
+          ErrorProng.return_error_prong(:elixir, [entrypoint(nif, :join)])
         end
+      )
+
+    error_prongs =
+      case {argument_error_prong, error_return_prong} do
+        {[], []} -> []
+        _ -> [catch: argument_error_prong ++ error_return_prong]
       end
 
+    function_block = function_code ++ error_prongs
+
+    quote context: Elixir do
+      unquote(Nif.style(nif))(
+        unquote(nif.name)(unquote_splicing(used_params_ast)),
+        unquote(function_block)
+      )
+
       defp unquote(entrypoint(nif, :launch))(unquote_splicing(unused_params_ast)) do
         :erlang.nif_error(unquote(Nif.binding_error(nif.name, arity)))
       end
@@ -100,9 +125,10 @@ defmodule Zig.Nif.Threaded do
     launch = entrypoint(nif, :launch)
     join = entrypoint(nif, :join)
 
-    launch_entries = nif
-    |> Nif.arities()
-    |> Enum.flat_map(&[{launch, &1, :"@\"#{launch}\"", :synchronous}])
+    launch_entries =
+      nif
+      |> Nif.arities()
+      |> Enum.flat_map(&[{launch, &1, :"@\"#{launch}\"", :synchronous}])
 
     [{join, 1, :"@\"#{join}\"", :synchronous} | launch_entries]
   end
@@ -114,10 +140,10 @@ defmodule Zig.Nif.Threaded do
   @impl true
   def resources(nif), do: [{:root, :"@\"ThreadResource-#{nif.name}\""}]
 
-  #defp error_prongs(nif) do
+  # defp error_prongs(nif) do
   #  nif.signature.params
   #  |> Enum.map(&Type.error_prongs(&1, :argument))
   #  |> List.insert_at(0, Type.error_prongs(nif.signature.return, :return))
   #  |> List.flatten()
-  #end
+  # end
 end

lib/zig/resources.ex

@@ -7,11 +7,15 @@ defmodule Zig.Resources do
   EEx.function_from_file(:def, :render, resources, [:assigns])
 
   defp beam_type(resource) do
-    inner_name = case Atom.to_string(resource) do
-      "@" <> rest ->
-        String.trim(rest, "\"")
-      normal -> normal
-    end
+    inner_name =
+      case Atom.to_string(resource) do
+        "@" <> rest ->
+          String.trim(rest, "\"")
+
+        normal ->
+          normal
+      end
+
     ~s(@"beam-type-#{inner_name}")
   end
 

lib/zig/sema.ex

@@ -144,7 +144,7 @@ defmodule Zig.Sema do
             nif_opts = Keyword.get(specified_fns, function.name, module.default_nif_opts)
 
             function.name
-            |> Nif.new(module.module_code_path, nif_opts |> dbg)
+            |> Nif.new(module.module_code_path, nif_opts)
             |> apply_from_sema(function, nif_opts)
             |> set_file_line(module.manifest_module, module.parsed)
           end)
@@ -153,7 +153,7 @@ defmodule Zig.Sema do
           Enum.map(selected_fns, fn {name, nif_opts} ->
             if function = Enum.find(functions, &(&1.name == name)) do
               name
-              |> Nif.new(module.module_code_path, nif_opts |> dbg)
+              |> Nif.new(module.module_code_path, nif_opts)
               |> apply_from_sema(function, nif_opts)
               |> set_file_line(module.manifest_module, module.parsed)
             else

test/integration/concurrency/threaded_automatic_erroring_test.exs

@@ -2,40 +2,40 @@ defmodule ZiglerTest.Concurrency.ThreadedAutomaticErroringTest do
   use ZiglerTest.IntegrationCase, async: true
 
   @moduletag [threaded: true, erroring: true]
-  test "restore"
-
-  #  use Zig, otp_app: :zigler, nifs: [threaded: [:threaded]]
-  #
-  #  ~Z"""
-  #  const beam = @import("beam");
-  #
-  #  const ThreadError = error{BadNumber};
-  #
-  #  pub fn threaded(number: i32) !i32 {
-  #    if (number == 42) { return error.BadNumber; }
-  #    return number + 1;
-  #  }
-  #  """
-  #
-  #  test "threaded function can succeed" do
-  #    assert 48 = threaded(47)
-  #  end
-  #
-  #  # note the line numbers might not be correct, hence the skip.
-  #  @tag :skip
-  #  test "threaded function can error" do
-  #    error =
-  #      try do
-  #        threaded(42)
-  #      rescue
-  #        e in ErlangError ->
-  #          %{payload: e.original, stacktrace: __STACKTRACE__}
-  #      end
-  #
-  #    assert %{payload: :BadNumber, stacktrace: [head | _]} = error
-  #
-  #    expected_file = Path.absname(__ENV__.file)
-  #
-  #    assert {__MODULE__, :threaded, [:...], [file: ^expected_file, line: 13]} = head
-  #  end
+
+  use Zig, otp_app: :zigler, nifs: [threaded: [:threaded]]
+
+  ~Z"""
+  const beam = @import("beam");
+
+  const ThreadError = error{BadNumber};
+
+  pub fn threaded(number: i32) !i32 {
+    if (number == 42) { return error.BadNumber; }
+    return number + 1;
+  }
+  """
+
+  test "threaded function can succeed" do
+    assert 48 = threaded(47)
+  end
+
+  # note the line numbers might not be correct, hence the skip.
+  test "threaded function can error" do
+    error =
+      try do
+        threaded(42)
+      rescue
+        e in ErlangError ->
+          %{payload: e.original, stacktrace: __STACKTRACE__}
+      end
+
+    assert %{payload: :BadNumber, stacktrace: [head | _] = stacktrace} = error
+
+    expected_file = Path.absname(__ENV__.file)
+
+    assert {__MODULE__, :threaded, [:...], [file: ^expected_file, line: 14]} = head
+
+    refute Enum.any?(stacktrace, fn {_, function, _, _} -> function == :"threaded-join" end)
+  end
 end