Get tuple type checking

lib/orb/i32/dsl.ex

@@ -8,9 +8,22 @@ defmodule Orb.I32.DSL do
   """
 
   import Kernel, except: [+: 2, -: 2, *: 2, ===: 2, !==: 2, not: 1, or: 2]
+  alias Orb.Ops
 
   def left + right do
-    Orb.Numeric.Add.optimized(Orb.I32, left, right)
+    case Ops.extract_common_type(left, right) do
+      Integer ->
+        Kernel.+(left, right)
+
+      :i64 ->
+        Orb.Numeric.Add.optimized(Orb.I64, left, right)
+
+      :i32 ->
+        Orb.Numeric.Add.optimized(Orb.I32, left, right)
+
+      :f32 ->
+        Orb.F32.add(left, right)
+    end
   end
 
   def left - right do
@@ -30,8 +43,6 @@ defmodule Orb.I32.DSL do
   end
 
   def left === right do
-    alias Orb.Ops
-
     case Ops.extract_common_type(left, right) do
       :i64 ->
         Orb.I64.eq(left, right)

lib/orb/ops.ex

@@ -47,6 +47,13 @@ defmodule Orb.Ops do
   def to_primitive_type(type) when is_effect(type), do: type
   def to_primitive_type(type) when type in @elixir_types, do: type
 
+  def to_primitive_type(type) when is_tuple(type) do
+    for nested <- Tuple.to_list(type) do
+      to_primitive_type(nested)
+    end
+    |> List.to_tuple()
+  end
+
   def to_primitive_type(mod) when is_atom(mod) do
     Orb.CustomType.resolve!(mod) |> to_primitive_type()
   end

lib/orb/s32.ex

@@ -7,9 +7,24 @@ defmodule Orb.S32 do
     """
 
     import Kernel, except: [/: 2, <: 2, >: 2, <=: 2, >=: 2]
+    alias Orb.{Ops, F32}
 
     def left / right do
-      Orb.I32.div_s(left, right)
+      # Orb.I32.div_s(left, right)
+      case Ops.extract_common_type(left, right) do
+        Integer ->
+          Orb.I32.div_s(left, right)
+          # Kernel.div(left, right)
+
+        :i64 ->
+          Orb.I64.div_s(left, right)
+
+        :i32 ->
+          Orb.I32.div_s(left, right)
+
+        :f32 ->
+          Orb.F32.div(left, right)
+      end
     end
 
     def left >>> right do

test/orb_test.exs

@@ -738,35 +738,61 @@ defmodule OrbTest do
     assert Instance.call(inst, :calculate_mean_and_count) == {5, 3}
   end
 
-  defmodule FileNameSafe do
-    use Orb
+  test "tuple types" do
+    defmodule TupleTypes do
+      use Orb
 
-    Memory.pages(2)
+      defw rgb_reverse(r: F32, g: F32, b: F32), {F32, F32, F32} do
+        b
+        g
+        r
+      end
 
-    wasm do
-      func get_is_valid(), I32, str: I32.U8.UnsafePointer, char: I32 do
-        str = 1024
-
-        loop Loop, result: I32 do
-          Control.block Outer do
-            Control.block :inner do
-              char = str[at!: 0]
-              Control.break(:inner, if: I32.eq(char, ?/))
-              Outer.break(if: char)
-              return(1)
+      defw rgb_average(r: F32, g: F32, b: F32), F32 do
+        (b + g + r) / 3.0
+      end
+
+      def main do
+        rgb_reverse(1.0, 0.5, 0.0)
+        :drop
+        :drop
+        :drop
+      end
+    end
+
+    alias OrbWasmtime.Wasm
+    assert {0.0, 0.5, 1.0} === Wasm.call(TupleTypes, :rgb_reverse, 1.0, 0.5, 0.0)
+  end
+
+  test "loop" do
+    defmodule FileNameSafe do
+      use Orb
+
+      Memory.pages(2)
+
+      wasm do
+        func get_is_valid(), I32, str: I32.U8.UnsafePointer, char: I32 do
+          str = 1024
+
+          loop Loop, result: I32 do
+            Control.block Outer do
+              Control.block :inner do
+                char = str[at!: 0]
+                Control.break(:inner, if: I32.eq(char, ?/))
+                Outer.break(if: char)
+                return(1)
+              end
+
+              return(0)
             end
 
-            return(0)
+            str = str + 1
+            Loop.continue()
           end
-
-          str = str + 1
-          Loop.continue()
         end
       end
     end
-  end
 
-  test "loop" do
     wasm_source = """
     (module $FileNameSafe
       (memory (export "memory") 2)