Fix type to string representation for complex types

lib/ham/type_match_error.ex

@@ -4,9 +4,11 @@ defmodule Ham.TypeMatchError do
   match types defined in typespecs.
   """
   defexception [:reasons]
+
   @type t :: %__MODULE__{}
 
   alias Ham.Utils
+  import Ham.Utils, only: [type_to_string: 1]
 
   @impl Exception
   def exception({:error, reasons}), do: %__MODULE__{reasons: reasons}
@@ -123,27 +125,4 @@ defmodule Ham.TypeMatchError do
 
     padding <> string
   end
-
-  defp type_to_string({:type, _, :map_field_exact, [type1, type2]}) do
-    "required(#{type_to_string(type1)}) => #{type_to_string(type2)}"
-  end
-
-  defp type_to_string({:type, _, :map_field_assoc, [type1, type2]}) do
-    "optional(#{type_to_string(type1)}) => #{type_to_string(type2)}"
-  end
-
-  defp type_to_string(type) do
-    # We really want to access Code.Typespec.typespec_to_quoted/1 here but it's
-    # private... this hack needs to suffice.
-    {:foo, type, []}
-    |> Code.Typespec.type_to_quoted()
-    |> Macro.to_string()
-    |> String.split("\n")
-    |> Enum.map_join(&String.replace(&1, ~r/ +/, " "))
-    |> String.split(" :: ")
-    |> case do
-      [_, type_string] -> type_string
-      [_, type_name, type_string] -> "#{type_string} (\"#{type_name}\")"
-    end
-  end
 end

lib/ham/utils.ex

@@ -63,4 +63,38 @@ defmodule Ham.Utils do
   defp suffix(2), do: "nd"
   defp suffix(3), do: "rd"
   defp suffix(_), do: "th"
+
+  def type_to_string({:type, _, :map_field_exact, [type1, type2]}) do
+    "required(#{type_to_string(type1)}) => #{type_to_string(type2)}"
+  end
+
+  def type_to_string({:type, _, :map_field_assoc, [type1, type2]}) do
+    "optional(#{type_to_string(type1)}) => #{type_to_string(type2)}"
+  end
+
+  def type_to_string(type) do
+    # We really want to access Code.Typespec.typespec_to_quoted/1 here but it's
+    # private... this hack needs to suffice.
+    macro =
+      {:foo, type, []}
+      |> Code.Typespec.type_to_quoted()
+
+    macro
+    |> Macro.to_string()
+    |> String.split("\n")
+    |> Enum.map_join(&String.replace(&1, ~r/ +/, " "))
+    |> String.split(" :: ", parts: type_parts(macro))
+    |> case do
+      [_foo, type_string] -> type_string
+      [_foo, type_name, type_string] -> "#{type_string} (\"#{type_name}\")"
+    end
+  end
+
+  defp type_parts(macro) do
+    case macro do
+      # The type has a name
+      {:"::", [], [{:foo, [], []}, {:"::", _, _}]} -> 3
+      _ -> 2
+    end
+  end
 end

test/ham/type_checker_test.exs

@@ -1272,6 +1272,21 @@ defmodule Ham.TypeCheckerTest do
     end
   end
 
+  describe "multiple options" do
+    test "pass" do
+      assert_pass(:foo_multiple_options_annotated, [], {:ok, "a", "b"})
+    end
+
+    test "fail" do
+      assert_fail(
+        :foo_multiple_options_annotated,
+        [],
+        :ok,
+        ~r/type \{:ok, binary\(\), req :: binary\(\)\} | \{:more, binary\(\), req :: binary\(\)\} \("result"\)/
+      )
+    end
+  end
+
   test "nospec" do
     assert_pass(:nospec_fun, [], :ok)
   end

test/ham/utils_test.exs

@@ -0,0 +1,26 @@
+defmodule Ham.UtilsTest do
+  use ExUnit.Case, async: true
+  alias Ham.Utils
+
+  defp fetch_test_type(type_name) do
+    {:ok, types} =
+      Code.Typespec.fetch_types(Ham.Test.TestModule)
+
+    Enum.find_value(types, fn
+      {:type, {^type_name, type, _}} -> type
+      _ -> nil
+    end)
+  end
+
+  describe "type_to_string/1" do
+    test "complex type" do
+      assert :complex |> fetch_test_type() |> Utils.type_to_string() ==
+               "{:ok, binary(), req :: binary()} | {:more, binary(), req :: binary()}"
+    end
+
+    test "complex type with annotation" do
+      assert :complex_annotated |> fetch_test_type() |> Utils.type_to_string() ==
+               "{:ok, binary(), req :: binary()} | {:more, binary(), req :: binary()} (\"result\")"
+    end
+  end
+end

test/support/module.ex

@@ -240,4 +240,17 @@ defmodule Ham.Test.TestModule do
   def foo_guarded(_arg), do: [1]
 
   def nospec_fun, do: :ok
+
+  @spec map_type_with_underscore() :: :test.req()
+  def map_type_with_underscore, do: %{method: "GET"}
+
+  @type complex :: {:ok, binary(), req :: binary()} | {:more, binary(), req :: binary()}
+  @type complex_annotated ::
+          result :: {:ok, binary(), req :: binary()} | {:more, binary(), req :: binary()}
+
+  @spec foo_multiple_options_annotated :: complex_annotated
+  def foo_multiple_options_annotated, do: {:ok, "a", "b"}
+
+  @spec foo_multiple_options :: complex
+  def foo_multiple_options, do: {:ok, "a", "b"}
 end