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