Turn off refinements on dynamic calls

Author: josevalim

lib/elixir/lib/module/types.ex

@@ -401,14 +401,25 @@ defmodule Module.Types do
       module: module,
       # Current function
       function: function,
-      # List of calls to not warn on as undefined or :all or Macro.Env indicating limited remotes
+      # Handling of undefined remote calls. May be one of:
+      #
+      # * List of calls to not warn on as undefined
+      #
+      # * The atom `:all` to not mark anything as undefined
+      #
+      # * A Macro.Env struct to not mark anything as undefined
+      #   also used to extract structs from
+      #
       no_warn_undefined: no_warn_undefined,
       # A tuple with cache information (may be nil)
       cache: cache,
       # The mode to be used, see the @modes attribute
       mode: mode,
       # The function for handling local calls
-      local_handler: handler
+      local_handler: handler,
+      # Control if variable refinment is enabled.
+      # It is disabled only on dynamic dispatches.
+      refine_vars: true
     }
   end
 

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

@@ -517,10 +517,10 @@ defmodule Module.Types.Expr do
 
   # var
   def of_expr(var, expected, expr, stack, context) when is_var(var) do
-    if stack.mode == :traversal do
-      {dynamic(), context}
-    else
-      Of.refine_body_var(var, expected, expr, stack, context)
+    case stack do
+      %{mode: :traversal} -> {dynamic(), context}
+      %{refine_vars: false} -> {Of.var(var, context), context}
+      %{} -> Of.refine_body_var(var, expected, expr, stack, context)
     end
   end
 
@@ -715,7 +715,7 @@ defmodule Module.Types.Expr 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, context)
+        apply_one(mod, fun, args, expected, expr, %{stack | refine_vars: false}, context)
       end)
 
     {Enum.reduce(returns, &union/2), context}

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

@@ -362,27 +362,51 @@ defmodule Module.Types.ExprTest do
                """
     end
 
-    test "requires all combinations to be compatible" do
+    test "requires all combinations to be compatible (except refinements)" 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()])
+
       assert typeerror!(
-               [condition, string],
+               [condition],
                (
+                 arg = if condition, do: "foo", else: [?f, ?o, ?o]
                  mod = if condition, do: String, else: List
-                 mod.to_integer(string)
+                 mod.to_integer(arg)
                )
              )
              |> strip_ansi() == ~l"""
-             incompatible types given to String.to_integer/1:
+             incompatible types given to List.to_integer/1:
 
-                 mod.to_integer(string)
-                 #=> invoked as String.to_integer/1
+                 mod.to_integer(arg)
+                 #=> invoked as List.to_integer/1
 
              given types:
 
-                 dynamic(non_empty_list(integer()))
+                 binary() or non_empty_list(integer())
 
              but expected one of:
 
-                 binary()
+                 non_empty_list(integer())
+
+             where "arg" was given the type:
+
+                 # type: binary() or non_empty_list(integer())
+                 # from: types_test.ex:LINE-5
+                 arg =
+                   if condition do
+                     "foo"
+                   else
+                     ~c"foo"
+                   end
 
              where "mod" was given the type:
 
@@ -394,13 +418,6 @@ defmodule Module.Types.ExprTest do
                    else
                      List
                    end
-
-             where "string" was given the type:
-
-                 # type: dynamic(non_empty_list(integer()))
-                 # from: types_test.ex:LINE-3
-                 mod.to_integer(string)
-                 #=> invoked as List.to_integer/1
              """
     end
   end
@@ -968,7 +985,7 @@ defmodule Module.Types.ExprTest do
              where "p" was given the type:
 
                  # type: %Point{x: integer(), y: nil, z: integer()}
-                 # from: types_test.ex:951
+                 # from: types_test.ex:LINE-4
                  p = %Point{..., x: 123}
              """
     end