Track simple variable assignment in type system

Author: josevalim

lib/elixir/lib/enum.ex

@@ -1432,7 +1432,7 @@ defmodule Enum do
     )
 
     # Avoid warnings about Dict
-    dict_module = Dict
+    dict_module = String.to_atom("Dict")
 
     reduce(reverse(enumerable), dict, fn entry, categories ->
       dict_module.update(categories, fun.(entry), [entry], &[entry | &1])

lib/elixir/lib/hash_dict.ex

@@ -258,13 +258,13 @@ end
 defimpl Enumerable, for: HashDict do
   def reduce(dict, acc, fun) do
     # Avoid warnings about HashDict being deprecated.
-    module = HashDict
+    module = String.to_atom("HashDict")
     module.reduce(dict, acc, fun)
   end
 
   def member?(dict, {key, value}) do
     # Avoid warnings about HashDict being deprecated.
-    module = HashDict
+    module = String.to_atom("HashDict")
     {:ok, match?({:ok, ^value}, module.fetch(dict, key))}
   end
 
@@ -274,7 +274,7 @@ defimpl Enumerable, for: HashDict do
 
   def count(dict) do
     # Avoid warnings about HashDict being deprecated.
-    module = HashDict
+    module = String.to_atom("HashDict")
     {:ok, module.size(dict)}
   end
 
@@ -286,7 +286,7 @@ end
 defimpl Collectable, for: HashDict do
   def into(original) do
     # Avoid warnings about HashDict being deprecated.
-    module = HashDict
+    module = String.to_atom("HashDict")
 
     collector_fun = fn
       dict, {:cont, {key, value}} -> module.put(dict, key, value)
@@ -303,7 +303,7 @@ defimpl Inspect, for: HashDict do
 
   def inspect(dict, opts) do
     # Avoid warnings about HashDict being deprecated.
-    module = HashDict
+    module = String.to_atom("HashDict")
     concat(["#HashDict<", Inspect.List.inspect(module.to_list(dict), opts), ">"])
   end
 end

lib/elixir/lib/hash_set.ex

@@ -272,19 +272,19 @@ end
 defimpl Enumerable, for: HashSet do
   def reduce(set, acc, fun) do
     # Avoid warnings about HashSet being deprecated.
-    module = HashSet
+    module = String.to_atom("HashSet")
     module.reduce(set, acc, fun)
   end
 
   def member?(set, term) do
     # Avoid warnings about HashSet being deprecated.
-    module = HashSet
+    module = String.to_atom("HashSet")
     {:ok, module.member?(set, term)}
   end
 
   def count(set) do
     # Avoid warnings about HashSet being deprecated.
-    module = HashSet
+    module = String.to_atom("HashSet")
     {:ok, module.size(set)}
   end
 
@@ -296,7 +296,7 @@ end
 defimpl Collectable, for: HashSet do
   def into(original) do
     # Avoid warnings about HashSet being deprecated.
-    module = HashSet
+    module = String.to_atom("HashSet")
 
     collector_fun = fn
       set, {:cont, term} -> module.put(set, term)
@@ -313,7 +313,7 @@ defimpl Inspect, for: HashSet do
 
   def inspect(set, opts) do
     # Avoid warnings about HashSet being deprecated.
-    module = HashSet
+    module = String.to_atom("HashSet")
     concat(["#HashSet<", Inspect.List.inspect(module.to_list(set), opts), ">"])
   end
 end

lib/elixir/lib/module/types/descr.ex

@@ -52,6 +52,7 @@ defmodule Module.Types.Descr do
   def integer(), do: %{bitmap: @bit_integer}
   def float(), do: %{bitmap: @bit_float}
   def fun(), do: %{bitmap: @bit_fun}
+  # TODO: We need to propagate any dynamic up
   def open_map(pairs), do: %{map: map_new(:open, Map.new(pairs))}
   def closed_map(pairs), do: %{map: map_new(:closed, Map.new(pairs))}
   def open_map(), do: %{map: @map_top}
@@ -89,6 +90,18 @@ defmodule Module.Types.Descr do
   def term?(descr), do: subtype_static(@term, Map.delete(descr, :dynamic))
   def gradual?(descr), do: is_map_key(descr, :dynamic)
 
+  @doc """
+  Make a whole type dynamic.
+
+  It is an optimized version of `intersection(dynamic(), type)`.
+  """
+  def dynamic(descr) do
+    case descr do
+      %{dynamic: dynamic} -> %{dynamic: dynamic}
+      %{} -> %{dynamic: descr}
+    end
+  end
+
   @doc """
   Computes the union of two descrs.
   """
@@ -675,8 +688,7 @@ defmodule Module.Types.Descr do
           {dynamic_optional?, dynamic_type} = map_fetch_static(dynamic, key)
           {static_optional?, static_type} = map_fetch_static(static, key)
 
-          {dynamic_optional? or static_optional?,
-           union(intersection(dynamic(), dynamic_type), static_type)}
+          {dynamic_optional? or static_optional?, union(dynamic(dynamic_type), static_type)}
         else
           :error
         end

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

@@ -97,11 +97,10 @@ defmodule Module.Types.Expr do
   end
 
   # TODO: left = right
+  # TODO: make sure the types are compatible
   def of_expr({:=, _meta, [left_expr, right_expr]}, stack, context) do
-    with {:ok, _left_type, context} <-
-           Pattern.of_pattern(left_expr, stack, context),
-         {:ok, right_type, context} <- of_expr(right_expr, stack, context) do
-      {:ok, right_type, context}
+    with {:ok, right_type, context} <- of_expr(right_expr, stack, context) do
+      Pattern.of_pattern(left_expr, {right_type, right_expr}, stack, context)
     end
   end
 

lib/elixir/lib/module/types/helpers.ex

@@ -100,42 +100,6 @@ defmodule Module.Types.Helpers do
 
   defp do_reduce_ok([], acc, _fun), do: {:ok, acc}
 
-  @doc """
-  Like `Enum.unzip/1` but only continues while `fun` returns `{:ok, elem1, elem2}`
-  and stops on `{:error, reason}`.
-  """
-  def unzip_ok(list) do
-    do_unzip_ok(list, [], [])
-  end
-
-  defp do_unzip_ok([{:ok, head1, head2} | tail], acc1, acc2) do
-    do_unzip_ok(tail, [head1 | acc1], [head2 | acc2])
-  end
-
-  defp do_unzip_ok([{:error, reason} | _tail], _acc1, _acc2), do: {:error, reason}
-
-  defp do_unzip_ok([], acc1, acc2), do: {:ok, Enum.reverse(acc1), Enum.reverse(acc2)}
-
-  @doc """
-  Like `Enum.map/2` but only continues while `fun` returns `{:ok, elem}`
-  and stops on `{:error, reason}`.
-  """
-  def map_ok(list, fun) do
-    do_map_ok(list, [], fun)
-  end
-
-  defp do_map_ok([head | tail], acc, fun) do
-    case fun.(head) do
-      {:ok, elem} ->
-        do_map_ok(tail, [elem | acc], fun)
-
-      {:error, reason} ->
-        {:error, reason}
-    end
-  end
-
-  defp do_map_ok([], acc, _fun), do: {:ok, Enum.reverse(acc)}
-
   @doc """
   Like `Enum.map_reduce/3` but only continues while `fun` returns `{:ok, elem, acc}`
   and stops on `{:error, reason}`.
@@ -155,71 +119,4 @@ defmodule Module.Types.Helpers do
   end
 
   defp do_map_reduce_ok([], {list, acc}, _fun), do: {:ok, Enum.reverse(list), acc}
-
-  @doc """
-  Like `Enum.flat_map/2` but only continues while `fun` returns `{:ok, list}`
-  and stops on `{:error, reason}`.
-  """
-  def flat_map_ok(list, fun) do
-    do_flat_map_ok(list, [], fun)
-  end
-
-  defp do_flat_map_ok([head | tail], acc, fun) do
-    case fun.(head) do
-      {:ok, elem} ->
-        do_flat_map_ok(tail, [elem | acc], fun)
-
-      {:error, reason} ->
-        {:error, reason}
-    end
-  end
-
-  defp do_flat_map_ok([], acc, _fun), do: {:ok, Enum.reverse(Enum.concat(acc))}
-
-  @doc """
-  Like `Enum.flat_map_reduce/3` but only continues while `fun` returns `{:ok, list, acc}`
-  and stops on `{:error, reason}`.
-  """
-  def flat_map_reduce_ok(list, acc, fun) do
-    do_flat_map_reduce_ok(list, {[], acc}, fun)
-  end
-
-  defp do_flat_map_reduce_ok([head | tail], {list, acc}, fun) do
-    case fun.(head, acc) do
-      {:ok, elems, acc} ->
-        do_flat_map_reduce_ok(tail, {[elems | list], acc}, fun)
-
-      {:error, reason} ->
-        {:error, reason}
-    end
-  end
-
-  defp do_flat_map_reduce_ok([], {list, acc}, _fun),
-    do: {:ok, Enum.reverse(Enum.concat(list)), acc}
-
-  @doc """
-  Like `Enum.zip/1` but will zip multiple lists together instead of only two.
-  """
-  def zip_many(lists) do
-    zip_many(lists, [], [[]])
-  end
-
-  defp zip_many([], [], [[] | acc]) do
-    map_reverse(acc, [], &Enum.reverse/1)
-  end
-
-  defp zip_many([], remain, [last | acc]) do
-    zip_many(Enum.reverse(remain), [], [[] | [last | acc]])
-  end
-
-  defp zip_many([[] | _], remain, [last | acc]) do
-    zip_many(Enum.reverse(remain), [], [last | acc])
-  end
-
-  defp zip_many([[elem | list1] | list2], remain, [last | acc]) do
-    zip_many(list2, [list1 | remain], [[elem | last] | acc])
-  end
-
-  defp map_reverse([], acc, _fun), do: acc
-  defp map_reverse([head | tail], acc, fun), do: map_reverse(tail, [fun.(head) | acc], fun)
 end

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

@@ -47,7 +47,8 @@ defmodule Module.Types.Of do
 
       %{} ->
         data = %{
-          type: type,
+          # TODO: We should not default to dynamic on static mode
+          type: dynamic(type),
           name: var_name,
           context: var_context,
           off_traces: new_trace(expr, type, stack, [])

lib/elixir/lib/module/types/pattern.ex

@@ -30,7 +30,7 @@ defmodule Module.Types.Pattern do
 
   @doc """
   Return the type and typing context of a pattern expression with
-  the given {expected, expr} pair  or an error in case of a typing conflict.
+  the given {expected, expr} pair or an error in case of a typing conflict.
   """
 
   # ^var
@@ -40,9 +40,23 @@ defmodule Module.Types.Pattern do
 
   # left = right
   def of_pattern({:=, _meta, [left_expr, right_expr]}, expected_expr, stack, context) do
-    with {:ok, _, context} <- of_pattern(left_expr, expected_expr, stack, context),
-         {:ok, _, context} <- of_pattern(right_expr, expected_expr, stack, context),
-         do: {:ok, dynamic(), context}
+    # TODO: We need to properly track and annotate variables across (potentially nested) sides.
+    case {is_var(left_expr), is_var(right_expr)} do
+      {true, false} ->
+        with {:ok, type, context} <- of_pattern(right_expr, expected_expr, stack, context) do
+          of_pattern(left_expr, {type, right_expr}, stack, context)
+        end
+
+      {false, true} ->
+        with {:ok, type, context} <- of_pattern(left_expr, expected_expr, stack, context) do
+          of_pattern(right_expr, {type, left_expr}, stack, context)
+        end
+
+      {_, _} ->
+        with {:ok, _, context} <- of_pattern(left_expr, expected_expr, stack, context),
+             {:ok, _, context} <- of_pattern(right_expr, expected_expr, stack, context),
+             do: {:ok, dynamic(), context}
+    end
   end
 
   # %_{...}

lib/elixir/lib/uri.ex

@@ -235,7 +235,7 @@ defmodule URI do
 
       {{key, value}, rest} ->
         # Avoid warnings about Dict being deprecated
-        dict_module = Dict
+        dict_module = String.to_atom("Dict")
         decode_query_into_dict(rest, dict_module.put(dict, key, value), encoding)
     end
   end

lib/elixir/test/elixir/enum_test.exs

@@ -94,12 +94,12 @@ defmodule EnumTest do
   end
 
   test "chunk/3" do
-    enum = Enum
+    enum = String.to_atom("Elixir.Enum")
     assert enum.chunk(1..5, 2, 1) == Enum.chunk_every(1..5, 2, 1, :discard)
   end
 
   test "chunk/4" do
-    enum = Enum
+    enum = String.to_atom("Elixir.Enum")
     assert enum.chunk(1..5, 2, 1, nil) == Enum.chunk_every(1..5, 2, 1, :discard)
   end
 

lib/elixir/test/elixir/fixtures/dialyzer/remote_call.ex

@@ -23,7 +23,7 @@ defmodule Dialyzer.RemoteCall do
   end
 
   def mod_var() do
-    module = Hello
+    module = String.to_atom("Elixir.Hello")
     module.fun()
   end
 end

lib/elixir/test/elixir/integer_test.exs

@@ -189,7 +189,7 @@ defmodule IntegerTest do
   end
 
   test "to_charlist/2" do
-    module = Integer
+    module = String.to_atom("Elixir.Integer")
 
     assert Integer.to_charlist(42) == ~c"42"
     assert Integer.to_charlist(+42) == ~c"42"

lib/elixir/test/elixir/kernel/macros_test.exs

@@ -63,7 +63,7 @@ defmodule Kernel.MacrosTest do
   end
 
   test "macros cannot be called dynamically" do
-    x = Nested
+    x = String.to_atom("Elixir.Nested")
     assert_raise UndefinedFunctionError, fn -> x.func() end
   end
 

lib/elixir/test/elixir/macro_test.exs

@@ -599,7 +599,7 @@ defmodule MacroTest do
 
   describe "to_string/2" do
     defp macro_to_string(var, fun \\ fn _ast, string -> string end) do
-      module = Macro
+      module = String.to_atom("Elixir.Macro")
       module.to_string(var, fun)
     end
 

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

@@ -244,8 +244,21 @@ defmodule Module.Types.DescrTest do
     end
   end
 
-  describe "map operations" do
-    test "get field" do
+  describe "projections" do
+    test "atom_fetch" do
+      assert atom_fetch(term()) == :error
+      assert atom_fetch(union(term(), dynamic(atom([:foo, :bar])))) == :error
+
+      assert atom_fetch(atom()) == {:ok, []}
+
+      assert atom_fetch(atom([:foo, :bar])) ==
+               {:ok, [:foo, :bar] |> :sets.from_list(version: 2) |> :sets.to_list()}
+
+      assert atom_fetch(union(atom([:foo, :bar]), dynamic(atom()))) == {:ok, []}
+      assert atom_fetch(union(atom([:foo, :bar]), dynamic(term()))) == {:ok, []}
+    end
+
+    test "map_fetch" do
       assert map_fetch(closed_map(a: integer()), :a) == {false, integer()}
 
       assert map_fetch(term(), :a) == :error