Use conditional vars when applying across modules

Author: josevalim

lib/elixir/lib/module/types.ex

@@ -435,10 +435,7 @@ defmodule Module.Types do
       # The mode to be used, see the @modes attribute
       mode: mode,
       # The function for handling local calls
-      local_handler: handler,
-      # Control if variable refinement is enabled.
-      # It is disabled only on dynamic dispatches.
-      refine_vars: true
+      local_handler: handler
     }
   end
 

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

@@ -502,10 +502,7 @@ defmodule Module.Types.Expr do
 
   # var
   def of_expr(var, expected, expr, stack, context) when is_var(var) do
-    case stack do
-      %{refine_vars: false} -> {Of.var(var, context), context}
-      %{} -> Of.refine_body_var(var, expected, expr, stack, context)
-    end
+    Of.refine_body_var(var, expected, expr, stack, context)
   end
 
   ## Tuples
@@ -691,14 +688,14 @@ defmodule Module.Types.Expr do
     apply_one(mod, fun, args, expected, expr, stack, context)
   end
 
-  defp apply_many(mods, fun, args, expected, {remote, meta, args}, stack, context) do
-    {returns, context} =
-      Enum.map_reduce(mods, context, fn mod, context ->
-        expr = {remote, [type_check: {:invoked_as, mod, fun, length(args)}] ++ meta, args}
-        apply_one(mod, fun, args, expected, expr, %{stack | refine_vars: false}, context)
-      end)
+  defp apply_many(mods, fun, args, expected, call, stack, context) do
+    {remote, meta, _} = call
 
-    {Enum.reduce(returns, &union/2), context}
+    Of.with_conditional_vars(mods, none(), call, stack, context, fn mod, acc, context ->
+      expr = {remote, [type_check: {:invoked_as, mod, fun, length(args)}] ++ meta, args}
+      {type, context} = apply_one(mod, fun, args, expected, expr, stack, context)
+      {union(acc, type), context}
+    end)
   end
 
   defp reduce_non_empty([last], acc, fun),

lib/elixir/test/elixir/module/types/expr_test.exs

@@ -528,18 +528,15 @@ defmodule Module.Types.ExprTest do
                """
     end
 
-    test "requires all combinations to be compatible (except refinements)" do
+    test "computes union of all combinations" do
       assert typecheck!(
                [condition, arg],
                (
-                 # While the code below may raise, it may also always succeed
-                 # if condition and arg are passed in tandem. Therefore, we
-                 # turn off refinement on dynamic calls.
                  mod = if condition, do: String, else: List
                  res = mod.to_integer(arg)
                  {arg, res}
                )
-             ) == tuple([dynamic(), integer()])
+             ) == dynamic(tuple([union(binary(), non_empty_list(integer())), integer()]))
 
       assert typeerror!(
                [condition],