Clean up apply_infer/apply_strong

Author: josevalim

lib/elixir/lib/module/types/apply.ex

@@ -278,20 +278,19 @@ defmodule Module.Types.Apply do
         {_args_types, context} = apply_no_domain_args(args, args_fun, expr, stack, context)
         {dynamic(), context}
 
-      info ->
-        apply_remote(info, nil, name, args, args_fun, expr, stack, context)
-    end
-  end
+      {:strong, domain, clauses} ->
+        domain = domain(domain, clauses)
+        {args_types, context} = apply_args(args, domain, [], args_fun, expr, stack, context)
 
-  defp apply_remote(info, mod, fun, args, args_fun, expr, stack, context) do
-    case apply_signature(info, args, args_fun, expr, stack, context) do
-      {:ok, _indexes, type, context} ->
-        {type, context}
+        case apply_strong(domain, clauses, args_types, stack) do
+          {_used, type} ->
+            {type, context}
 
-      {:error, args_types, domain, clauses, context} ->
-        mfac = mfac(expr, mod, fun, length(args_types))
-        error = {{:badremote, clauses}, domain, args_types, mfac, expr, context}
-        {error_type(), error(error, elem(expr, 1), stack, context)}
+          :error ->
+            mfac = mfac(expr, nil, name, arity)
+            error = {{:badremote, clauses}, domain, args_types, mfac, expr, context}
+            {error_type(), error(error, elem(expr, 1), stack, context)}
+        end
     end
   end
 
@@ -375,7 +374,7 @@ defmodule Module.Types.Apply do
     {args_types, context} = apply_args(args, domain, [], args_fun, expr, stack, context)
 
     case remote_apply(info, args_types, stack) do
-      {:ok, _indexes, type} ->
+      {:ok, type} ->
         {type, context}
 
       {:error, error} ->
@@ -386,79 +385,61 @@ defmodule Module.Types.Apply do
   end
 
   defp remote_apply(:none, _args_types, _stack) do
-    {:ok, [], dynamic()}
+    {:ok, dynamic()}
   end
 
   defp remote_apply({:infer, _domain, clauses}, args_types, _stack) do
-    case apply_clauses(clauses, args_types, 0, 0, [], []) do
-      {0, [], []} ->
-        {:error, {:badremote, clauses}}
-
-      {count, used, _returns} when count > @max_clauses ->
-        {:ok, used, dynamic()}
-
-      {_count, used, returns} ->
-        {:ok, used, returns |> Enum.reduce(&union/2) |> dynamic()}
-    end
-  end
-
-  defp remote_apply({:strong, _, [{expected, return}] = clauses}, args_types, stack) do
-    # Optimize single clauses as the domain is the single clause args.
-    case zip_compatible?(args_types, expected) do
-      true -> {:ok, [0], return(return, args_types, stack)}
-      false -> {:error, {:badremote, clauses}}
+    case apply_infer(clauses, args_types) do
+      {_used, type} -> {:ok, type}
+      :error -> {:error, {:badremote, clauses}}
     end
   end
 
   defp remote_apply({:strong, domain, clauses}, args_types, stack) do
-    # If the type is only gradual, the compatibility check is the same
-    # as a non disjoint check. So we skip checking compatibility twice.
-    with true <- zip_compatible_or_only_gradual?(args_types, domain),
-         {count, used, returns} when count > 0 <- apply_clauses(clauses, args_types, 0, 0, [], []) do
-      {:ok, used, returns |> Enum.reduce(&union/2) |> return(args_types, stack)}
-    else
-      _ -> {:error, {:badremote, clauses}}
+    case apply_strong(domain, clauses, args_types, stack) do
+      {_used, type} -> {:ok, type}
+      :error -> {:error, {:badremote, clauses}}
     end
   end
 
   defp remote_apply({:element, index}, [_index, tuple], _stack) do
     case tuple_fetch(tuple, index - 1) do
-      {_optional?, value_type} -> {:ok, [0], value_type}
+      {_optional?, value_type} -> {:ok, value_type}
       :badtuple -> {:error, badremote(:erlang, :element, 2)}
       :badindex -> {:error, {:badindex, index, tuple}}
     end
   end
 
   defp remote_apply({:insert_element, index}, [_index, tuple, value], _stack) do
     case tuple_insert_at(tuple, index - 1, value) do
-      value_type when is_descr(value_type) -> {:ok, [0], value_type}
+      value_type when is_descr(value_type) -> {:ok, value_type}
       :badtuple -> {:error, badremote(:erlang, :insert_element, 3)}
       :badindex -> {:error, {:badindex, index - 1, tuple}}
     end
   end
 
   defp remote_apply({:delete_element, index}, [_index, tuple], _stack) do
     case tuple_delete_at(tuple, index - 1) do
-      value_type when is_descr(value_type) -> {:ok, [0], value_type}
+      value_type when is_descr(value_type) -> {:ok, value_type}
       :badtuple -> {:error, badremote(:erlang, :delete_element, 2)}
       :badindex -> {:error, {:badindex, index, tuple}}
     end
   end
 
   defp remote_apply({:make_tuple, size}, [_size, elem], _stack) do
-    {:ok, [0], tuple(List.duplicate(elem, size))}
+    {:ok, tuple(List.duplicate(elem, size))}
   end
 
   defp remote_apply(:hd, [list], _stack) do
     case list_hd(list) do
-      {_, value_type} -> {:ok, [0], value_type}
+      {_, value_type} -> {:ok, value_type}
       :badnonemptylist -> {:error, badremote(:erlang, :hd, 1)}
     end
   end
 
   defp remote_apply(:tl, [list], _stack) do
     case list_tl(list) do
-      {_, value_type} -> {:ok, [0], value_type}
+      {_, value_type} -> {:ok, value_type}
       :badnonemptylist -> {:error, badremote(:erlang, :tl, 1)}
     end
   end
@@ -473,20 +454,20 @@ defmodule Module.Types.Apply do
 
     cond do
       skip? ->
-        {:ok, [0], result}
+        {:ok, result}
 
       match?({false, _}, map_fetch(left, :__struct__)) or
           match?({false, _}, map_fetch(right, :__struct__)) ->
         {:error, :struct_comparison}
 
       number_type?(left) and number_type?(right) ->
-        {:ok, [0], result}
+        {:ok, result}
 
       disjoint?(left, right) ->
         {:error, :mismatched_comparison}
 
       true ->
-        {:ok, [0], result}
+        {:ok, result}
     end
   end
 
@@ -495,16 +476,16 @@ defmodule Module.Types.Apply do
 
     cond do
       skip? ->
-        {:ok, [0], result}
+        {:ok, result}
 
       name in [:==, :"/="] and number_type?(left) and number_type?(right) ->
-        {:ok, [0], result}
+        {:ok, result}
 
       disjoint?(left, right) ->
         {:error, :mismatched_comparison}
 
       true ->
-        {:ok, [0], result}
+        {:ok, result}
     end
   end
 
@@ -806,6 +787,38 @@ defmodule Module.Types.Apply do
     {Enum.reverse(acc), context}
   end
 
+  defp apply_infer(clauses, args_types) do
+    case apply_clauses(clauses, args_types, 0, 0, [], []) do
+      {0, [], []} ->
+        :error
+
+      {count, used, _returns} when count > @max_clauses ->
+        {used, dynamic()}
+
+      {_count, used, returns} ->
+        {used, returns |> Enum.reduce(&union/2) |> dynamic()}
+    end
+  end
+
+  defp apply_strong(_domain, [{expected, return}], args_types, stack) do
+    # Optimize single clauses as the domain is the single clause args.
+    case zip_compatible?(args_types, expected) do
+      true -> {[0], return(return, args_types, stack)}
+      false -> :error
+    end
+  end
+
+  defp apply_strong(domain, clauses, args_types, stack) do
+    # If the type is only gradual, the compatibility check is the same
+    # as a non disjoint check. So we skip checking compatibility twice.
+    with true <- zip_compatible_or_only_gradual?(args_types, domain),
+         {count, used, returns} when count > 0 <- apply_clauses(clauses, args_types, 0, 0, [], []) do
+      {used, returns |> Enum.reduce(&union/2) |> return(args_types, stack)}
+    else
+      _ -> :error
+    end
+  end
+
   defp apply_clauses([{expected, return} | clauses], args_types, index, count, used, returns) do
     if zip_not_disjoint?(args_types, expected) do
       apply_clauses(clauses, args_types, index + 1, count + 1, [index | used], [return | returns])