Remove map_update as we can implement as a has_key?+put

Author: josevalim

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

@@ -377,7 +377,7 @@ defmodule Module.Types.Descr do
     right_dynamic = Map.get(right, :dynamic, right)
 
     if empty?(left_static) do
-      not empty?(intersection(left_dynamic, right_dynamic))
+      not disjoint?(left_dynamic, right_dynamic)
     else
       subtype_static(left_static, right_dynamic)
     end
@@ -787,52 +787,6 @@ defmodule Module.Types.Descr do
     end
   end
 
-  @doc """
-  Updates the `key` with a given type, assuming that the key is present
-  in the descr, and that it is exclusively a map (or dynamic).
-  """
-  def map_update(:term, _key, _type), do: :badmap
-  def map_update(descr, key, :term), do: map_update_static_value(descr, key, :term)
-
-  def map_update(descr, key, type) do
-    case :maps.take(:dynamic, type) do
-      :error -> map_update_static_value(descr, key, type)
-      {dynamic, _static} -> dynamic(map_update_static_value(descr, key, dynamic))
-    end
-  end
-
-  def map_update_static_value(descr, key, type) do
-    case :maps.take(:dynamic, descr) do
-      :error ->
-        cond do
-          subtype?(descr, open_map([{key, term()}])) -> map_put_static(descr, key, type)
-          map_only?(descr) -> :badkey
-          true -> :badmap
-        end
-
-      {dynamic, static} when static == @none ->
-        if not disjoint?(dynamic, open_map([{key, term()}])) do
-          dynamic(map_put_static(dynamic, key, type))
-        else
-          :badkey
-        end
-
-      {dynamic, static} ->
-        if not disjoint?(dynamic, open_map([{key, term()}])) and
-             subtype?(static, open_map([{key, type}])) do
-          dynamic = map_put_static(dynamic, key, type)
-          static = map_put_static(static, key, type)
-          Map.put(static, :dynamic, dynamic)
-        else
-          if map_only?(static) do
-            :badkey
-          else
-            :badmap
-          end
-        end
-    end
-  end
-
   @doc """
   Adds a `key` of a given type, assuming that the descr is exclusively
   a map (or dynamic).
@@ -847,26 +801,26 @@ defmodule Module.Types.Descr do
     end
   end
 
-  def map_put_static_value(descr, key, type) do
+  defp map_put_static_value(descr, key, type) do
     case :maps.take(:dynamic, descr) do
       :error ->
         if map_only?(descr) do
-          map_put_static(descr, key, type)
+          map_put_static_descr(descr, key, type)
         else
           :badmap
         end
 
       {dynamic, static} when static == @none ->
         if descr_key?(dynamic, :map) do
-          dynamic(map_put_static(dynamic, key, type))
+          dynamic(map_put_static_descr(dynamic, key, type))
         else
           :badmap
         end
 
       {dynamic, static} ->
         if descr_key?(dynamic, :map) and map_only?(static) do
-          dynamic = map_put_static(dynamic, key, type)
-          static = map_put_static(static, key, type)
+          dynamic = map_put_static_descr(dynamic, key, type)
+          static = map_put_static_descr(static, key, type)
           union(dynamic(dynamic), static)
         else
           :badmap
@@ -875,7 +829,7 @@ defmodule Module.Types.Descr do
   end
 
   # Directly inserts a key of a given type into every positive and negative map
-  def map_put_static(descr, key, type) do
+  defp map_put_static_descr(descr, key, type) do
     map_delete_static(descr, key)
     |> Map.update!(:map, fn dnf ->
       Enum.map(dnf, fn {tag, fields, negs} ->

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

@@ -152,7 +152,7 @@ defmodule Module.Types.Expr do
          {:ok, struct_type, context} <-
            Of.struct(module, args_types, :only_defaults, struct_meta, stack, context),
          {:ok, map_type, context} <- of_expr(map, stack, context) do
-      if empty?(intersection(struct_type, map_type)) do
+      if disjoint?(struct_type, map_type) do
         warning = {:badupdate, :struct, expr, struct_type, map_type, context}
         {:ok, dynamic(), warn(__MODULE__, warning, update_meta, stack, context)}
       else

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

@@ -279,7 +279,7 @@ defmodule Module.Types.Of do
       number_type?(left) and number_type?(right) ->
         {:ok, result, context}
 
-      empty?(intersection(left, right)) ->
+      disjoint?(left, right) ->
         warning = {:mismatched_comparison, expr, context}
         {:ok, result, warn(warning, elem(expr, 1), stack, context)}
 

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

@@ -663,37 +663,6 @@ defmodule Module.Types.DescrTest do
     assert equal?(type, atom())
   end
 
-  test "map_update" do
-    assert map_update(empty_map(), :a, term()) == :badkey
-    assert map_update(open_map(), :a, term()) == :badkey
-    assert map_update(term(), :a, term()) == :badmap
-    assert map_update(closed_map(a: integer()), :b, atom()) == :badkey
-    assert map_update(open_map(a: integer()), :b, float()) == :badkey
-    assert map_update(closed_map(a: if_set(integer())), :b, atom()) == :badkey
-    assert map_update(union(dynamic(), empty_map()), :a, atom()) == :badkey
-    assert map_update(closed_map(a: integer()), :a, atom()) == closed_map(a: atom())
-    assert map_update(open_map(a: integer()), :a, atom()) |> equal?(open_map(a: atom()))
-    assert map_update(dynamic(open_map()), :a, integer()) == dynamic(open_map(a: integer()))
-
-    assert closed_map(a: if_set(atom()), b: float())
-           |> union(open_map(a: atom()))
-           |> map_update(:a, integer()) ==
-             :badkey
-
-    assert closed_map(a: if_set(atom()), b: float())
-           |> union(open_map(a: atom()))
-           |> difference(open_map(a: if_set(float())))
-           |> map_update(:a, integer())
-           |> map_fetch(:a) == {false, integer()}
-
-    assert map_update(difference(open_map(), open_map(a: not_set())), :a, fun()) ==
-             open_map(a: fun())
-
-    # Update a key-value pair with dynamic type
-    # Note: setting a field to a dynamic type makes the whole map become dynamic.
-    assert map_update(open_map(a: atom()), :a, dynamic()) |> equal?(dynamic(open_map(a: term())))
-  end
-
   describe "disjoint" do
     test "map" do
       refute disjoint?(open_map(), open_map(a: integer()))