makes more tests pass, up to marshalling

lib/zig/sema.ex

@@ -52,8 +52,8 @@ defmodule Zig.Sema do
 
   defp integrate_sema(%{"functions" => functions, "types" => types, "decls" => decls}, module) do
     %__MODULE__{
-      functions: Enum.map(functions, &Function.from_json(&1, module)),
-      types: Enum.map(types, &type_from_json(&1, module)),
+      functions: Enum.map(functions, &Function.from_json(&1, module.module)),
+      types: Enum.map(types, &type_from_json(&1, module.module)),
       decls: Enum.map(decls, &const_from_json/1)
     }
   end

lib/zig/templates/basic.zig.eex

@@ -15,7 +15,7 @@ fn <%= @name %>(env: beam.env, argc: c_int, args: [*c] const e.ErlNifTerm) callc
     return result_block: {
         const payload_opts = .{
             <%= for {index, param} <- @params do %>
-            <%= Type.render_payload_entry(param, index, needs_make?) %>
+            <%= Type.render_payload_options(param, index, needs_make?) %>
             <% end %>
         };
 

lib/zig/type.ex

@@ -36,12 +36,15 @@ defprotocol Zig.Type do
   def return_allowed?(type)
 
   # rendered zig code:
-  @spec render_payload_entry(t, non_neg_integer, boolean) :: iodata
-  def render_payload_entry(type, index, error_info?)
+  @spec render_payload_options(t, non_neg_integer, boolean) :: iodata
+  def render_payload_options(type, index, error_info?)
 
   @spec render_return(t) :: iodata
   def render_return(type)
 
+  @spec render_zig(t) :: String.T
+  def render_zig(type)
+
   @typep spec_context :: :param | :return
   @spec spec(t, spec_context, keyword) :: Macro.t()
   def spec(type, context, opts)
@@ -225,11 +228,13 @@ after
 
   # defaults
 
-  def _default_payload_entry, do: ".{.error_info = &error_info},"
+  def _default_payload_options, do: ".{.error_info = &error_info},"
   def _default_return, do: "break :result_block beam.make(result, .{}).v;"
 end
 
 defimpl Zig.Type, for: Atom do
+  alias Zig.Type
+
   def marshals_param?(_), do: false
   def marshals_return?(_), do: false
 
@@ -238,7 +243,17 @@ defimpl Zig.Type, for: Atom do
 
   def return_allowed?(type), do: type in ~w(term erl_nif_term pid void)a
 
-  def render_return(:void), do: ""
+  def render_return(:void), do: "_ = result; break :result_block beam.make(.ok, .{}).v;"
+  def render_return(_), do: Type._default_return()
+
+  def render_payload_options(:erl_nif_term, _, _), do: ".{}"
+  def render_payload_options(:term, _, _), do: ".{}"
+
+  def render_payload_options(type, _, _)
+      when type in ~w[env stacktrace erl_nif_binary erl_nif_event erl_nif_binary_pointer]a,
+      do: raise("unreachable")
+
+  def render_payload_options(_, _, _), do: Type._default_payload_options()
 
   def spec(:void, :return, _), do: :ok
 

lib/zig/type/array.ex

@@ -26,10 +26,11 @@ defmodule Zig.Type.Array do
     }
   end
 
+  def return_allowed?(array), do: Type.return_allowed?(array.child)
   def marshals_param?(_), do: false
   def marshals_return?(_), do: false
-
-  def return_allowed?(array), do: Type.return_allowed?(array.child)
+  def render_payload_options(type, index, _), do: Type._default_payload_options()
+  def render_return(type), do: Type._default_return()
 
   def spec(%{child: ~t(u8)} = type, :return, opts) do
     # u8 defaults to binary
@@ -113,8 +114,4 @@ defmodule Zig.Type.Array do
   def of(type, len, opts \\ []) do
     struct(__MODULE__, opts ++ [child: type, len: len])
   end
-
-  def render_payload_entry(type, index, _), do: Type._default_payload_entry()
-
-  def render_return(type), do: Type._default_return()
 end

lib/zig/type/bool.ex

@@ -10,5 +10,11 @@ defmodule Zig.Type.Bool do
 
   def return_allowed?(_), do: true
 
+  def render_payload_options(type, index, _), do: Type._default_payload_options()
+  def render_return(type), do: Type._default_return()
+
+  def marshals_param?(_), do: false
+  def marshals_return?(_), do: false
+
   def spec(_, _, _), do: Type.spec(:boolean)
 end

lib/zig/type/cpointer.ex

@@ -24,6 +24,12 @@ defmodule Zig.Type.Cpointer do
     end
   end
 
+  def marshals_param?(_), do: false
+  def marshals_return?(_), do: false
+
+  def render_payload_options(type, index, _), do: Type._default_payload_options()
+  def render_return(type), do: Type._default_return()
+
   def spec(%{child: child}, :param, _opts) do
     has_solo? = match?(%Type.Struct{extern: true}, child)
     child_form = Type.spec(child, :param, [])

lib/zig/type/enum.ex

@@ -1,5 +1,6 @@
 defmodule Zig.Type.Enum do
-  use Zig.Type
+  alias Zig.Type
+  use Type
 
   defstruct [:tags, :name]
   @type t :: %__MODULE__{tags: %{optional(atom) => String.t()}, name: String.t()}
@@ -17,6 +18,12 @@ defmodule Zig.Type.Enum do
 
   def return_allowed?(_), do: true
 
+  def marshals_param?(_), do: false
+  def marshals_return?(_), do: false
+
+  def render_payload_options(type, index, _), do: Type._default_payload_options()
+  def render_return(type), do: Type._default_return()
+
   def spec(%{tags: tags}, _, _opts) do
     tags
     |> Map.keys()

lib/zig/type/float.ex

@@ -22,4 +22,8 @@ defmodule Zig.Type.Float do
   def spec(_, _, _), do: Type.spec(:float)
 
   def return_allowed?(_), do: true
+  def marshals_param?(_), do: false
+  def marshals_return?(_), do: false
+  def render_payload_options(type, index, _), do: Type._default_payload_options()
+  def render_return(type), do: Type._default_return()
 end

lib/zig/type/integer.ex

@@ -20,6 +20,10 @@ defmodule Zig.Type.Integer do
 
   def parse(other), do: raise(Zig.Type.ParseError, source: other)
 
+  def render_zig(%{bits: :big}), do: raise("not supported yet")
+  def render_zig(%{signedness: :unsigned, bits: bits}), do: "u#{bits}"
+  def render_zig(%{signedness: :signed, bits: bits}), do: "i#{bits}"
+
   @signs %{"signed" => :signed, "unsigned" => :unsigned}
   def from_json(%{"signedness" => s, "bits" => b}) do
     %__MODULE__{signedness: Map.fetch!(@signs, s), bits: b}
@@ -65,7 +69,7 @@ defmodule Zig.Type.Integer do
     guards =
       quote bind_quoted: [
               variable: variable,
-              name: to_string(type),
+              name: Type.render_zig(type),
               index: index,
               max: max,
               min: min
@@ -219,4 +223,10 @@ defmodule Zig.Type.Integer do
   def return_allowed?(_), do: true
 
   def render_return(type), do: Type._default_return()
+
+  def marshals_param?(%{bits: bits}), do: bits > 64
+  def marshals_return?(%{bits: bits}), do: bits > 64
+
+  def render_payload_options(type, index, _), do: Type._default_payload_options()
+  def render_return(type), do: Type._default_return()
 end

lib/zig/type/manypointer.ex

@@ -26,6 +26,11 @@ defmodule Zig.Type.Manypointer do
   def return_allowed?(pointer), do: pointer.has_sentinel? and Type.return_allowed?(pointer.child)
   def missing_size?(_), do: true
 
+  def marshals_param?(_), do: false
+  def marshals_return?(_), do: false
+  def render_payload_options(type, index, _), do: Type._default_payload_options()
+  def render_return(type), do: Type._default_return()
+
   # only manypointers of [*:0]u8 are allowed to be returned.
   def spec(%{child: ~t(u8), has_sentinel?: true}, :return, opts) do
     case Keyword.fetch!(opts, :type) do

lib/zig/type/optional.ex

@@ -11,6 +11,12 @@ defmodule Zig.Type.Optional do
 
   def return_allowed?(optional), do: Type.return_allowed?(optional.child)
 
+  def marshals_param?(_), do: false
+  def marshals_return?(_), do: false
+
+  def render_payload_options(type, index, _), do: Type._default_payload_options()
+  def render_return(type), do: Type._default_return()
+
   def spec(%{child: child}, context, opts) do
     quote do
       unquote(Type.spec(child, context, opts)) | nil

lib/zig/type/slice.ex

@@ -81,6 +81,10 @@ defmodule Zig.Type.Slice do
   # ETC
 
   def return_allowed?(slice), do: Type.return_allowed?(slice.child)
+  def marshals_param?(_), do: false
+  def marshals_return?(_), do: false
+  def render_payload_options(type, index, _), do: Type._default_payload_options()
+  def render_return(type), do: Type._default_return()
 
   def of(child, opts \\ []), do: struct(__MODULE__, [child: child] ++ opts)
 end

lib/zig/type/struct.ex

@@ -118,4 +118,9 @@ defmodule Zig.Type.Struct do
     |> Enum.map(&Type.return_allowed?/1)
     |> Enum.all?()
   end
+
+  def marshals_param?(_), do: false
+  def marshals_return?(_), do: false
+  def render_payload_options(type, index, _), do: Type._default_payload_options()
+  def render_return(type), do: Type._default_return()
 end