Unify apply and remote handling

Author: josevalim

lib/elixir/lib/module/types/expr.ex

@@ -274,7 +274,7 @@ defmodule Module.Types.Expr do
     if Keyword.get(meta, :no_parens, false) do
       Of.map_fetch(expr, type, key_or_fun, stack, context)
     else
-      {mods, context} = Of.remote(type, key_or_fun, 0, [:dot], expr, meta, stack, context)
+      {mods, context} = Of.modules(type, key_or_fun, 0, [:dot], expr, meta, stack, context)
       apply_many(mods, key_or_fun, [], expr, stack, context)
     end
   end
@@ -283,7 +283,7 @@ defmodule Module.Types.Expr do
   def of_expr({{:., _, [remote, name]}, meta, args} = expr, stack, context) do
     {remote_type, context} = of_expr(remote, stack, context)
     {args_types, context} = Enum.map_reduce(args, context, &of_expr(&1, stack, &2))
-    {mods, context} = Of.remote(remote_type, name, length(args), expr, meta, stack, context)
+    {mods, context} = Of.modules(remote_type, name, length(args), expr, meta, stack, context)
     apply_many(mods, name, args_types, expr, stack, context)
   end
 
@@ -297,7 +297,8 @@ defmodule Module.Types.Expr do
     {remote_type, context} = of_expr(remote, stack, context)
     # TODO: We cannot return the unions of functions. Do we forbid this?
     # Do we check it is always the same return type? Do we simply say it is a function?
-    {_mods, context} = Of.remote(remote_type, name, arity, expr, meta, stack, context)
+    {mods, context} = Of.modules(remote_type, name, arity, expr, meta, stack, context)
+    context = Enum.reduce(mods, context, &Of.remote(&1, name, arity, meta, stack, &2))
     {fun(), context}
   end
 

lib/elixir/lib/module/types/of.ex

@@ -293,7 +293,7 @@ defmodule Module.Types.Of do
     context
   end
 
-  ## Apply
+  ## Remotes
 
   # TODO: Implement element without a literal index
 
@@ -399,23 +399,25 @@ defmodule Module.Types.Of do
     end
   end
 
-  def apply(mod, name, args, expr, stack, context) do
-    case :elixir_rewrite.inline(mod, name, length(args)) do
-      {mod, name} -> apply(mod, name, args, expr, stack, context)
-      false -> {dynamic(), context}
+  def apply(mod, name, args_types, expr, stack, context) do
+    arity = length(args_types)
+
+    case :elixir_rewrite.inline(mod, name, arity) do
+      {mod, name} ->
+        apply(mod, name, args_types, expr, stack, context)
+
+      false ->
+        context = remote(mod, name, arity, elem(expr, 1), stack, context)
+        {dynamic(), context}
     end
   end
 
-  ## Remote
-
-  def remote(type, fun, arity, hints \\ [], expr, meta, stack, context) do
+  @doc """
+  Returns the modules for a given call.
+  """
+  def modules(type, fun, arity, hints \\ [], expr, meta, stack, context) do
     case atom_fetch(type) do
       {_, mods} ->
-        context =
-          Enum.reduce(mods, context, fn mod, context ->
-            remote(mod, fun, arity, meta, stack, context)
-          end)
-
         {mods, context}
 
       :error ->