Properly propagate if_set on Map operations

Author: josevalim

lib/elixir/lib/map.ex

@@ -408,8 +408,8 @@ defmodule Map do
       iex> Map.replace(%{a: 1, b: 2}, :a, 3)
       %{a: 3, b: 2}
 
-      iex> Map.replace(%{a: 1}, :b, 2)
-      %{a: 1}
+      iex> Map.replace(%{"a" => 1}, "b", 2)
+      %{"a" => 1}
 
   """
   @doc since: "1.11.0"
@@ -467,8 +467,8 @@ defmodule Map do
       iex> Map.replace_lazy(%{a: 1, b: 2}, :a, fn v -> v * 4 end)
       %{a: 4, b: 2}
 
-      iex> Map.replace_lazy(%{a: 1, b: 2}, :c, fn v -> v * 4 end)
-      %{a: 1, b: 2}
+      iex> Map.replace_lazy(%{"a" => 1, "b" => 2}, "c", fn v -> v * 4 end)
+      %{"a" => 1, "b" => 2}
 
   """
   @doc since: "1.14.0"
@@ -571,15 +571,13 @@ defmodule Map do
 
   ## Examples
 
-      iex> Map.get(%{}, :a)
-      nil
-      iex> Map.get(%{a: 1}, :a)
+      iex> Map.get(%{"a" => 1}, "a")
       1
-      iex> Map.get(%{a: 1}, :b)
+      iex> Map.get(%{"a" => 1}, "b")
       nil
-      iex> Map.get(%{a: 1}, :b, 3)
+      iex> Map.get(%{"a" => 1}, "b", 3)
       3
-      iex> Map.get(%{a: nil}, :a, 1)
+      iex> Map.get(%{"a" => nil}, "a", 1)
       nil
 
   """
@@ -608,15 +606,11 @@ defmodule Map do
 
   ## Examples
 
-      iex> map = %{a: 1}
-      iex> fun = fn ->
-      ...>   # some expensive operation here
-      ...>   13
-      ...> end
-      iex> Map.get_lazy(map, :a, fun)
+      iex> Map.get_lazy(%{a: 1}, :a, fn -> :expensive_value end)
       1
-      iex> Map.get_lazy(map, :b, fun)
-      13
+
+      iex> Map.get_lazy(%{"a" => 1}, "b", fn -> :expensive_value end)
+      :expensive_value
 
   """
   @spec get_lazy(map, key, (-> value)) :: value
@@ -808,15 +802,11 @@ defmodule Map do
 
   ## Examples
 
-      iex> map = %{a: 1}
-      iex> fun = fn ->
-      ...>   # some expensive operation here
-      ...>   13
-      ...> end
-      iex> Map.pop_lazy(map, :a, fun)
+      iex> Map.pop_lazy(%{a: 1}, :a, fn -> :expensive_value end)
       {1, %{}}
-      iex> Map.pop_lazy(map, :b, fun)
-      {13, %{a: 1}}
+
+      iex> Map.pop_lazy(%{"a" => 1}, "b", fn -> :expensive_value end)
+      {:expensive_value, %{"a" => 1}}
 
   """
   @spec pop_lazy(map, key, (-> value)) :: {value, map}

lib/elixir/lib/module/types/apply.ex

@@ -519,7 +519,9 @@ defmodule Module.Types.Apply do
   end
 
   defp remote_apply(Map, :replace, _info, [map, key, value] = args_types, stack) do
-    case map_update(map, key, value, false, false) do
+    fun = fn optional?, _type -> if optional?, do: if_set(value), else: value end
+
+    case map_update_fun(map, key, fun, false, false) do
       {_value, descr, _errors} -> {:ok, return(descr, args_types, stack)}
       :badmap -> {:error, badremote(Map, :replace, args_types)}
       {:error, _errors} -> {:error, {:badkeydomain, map, key, "do nothing"}}
@@ -671,7 +673,9 @@ defmodule Module.Types.Apply do
   end
 
   defp remote_apply(:maps, :update, _info, [key, value, map] = args_types, stack) do
-    case map_update(map, key, value, false, false) do
+    fun = fn optional?, _type -> if optional?, do: if_set(value), else: value end
+
+    case map_update_fun(map, key, fun, false, false) do
       {_value, descr, _errors} -> {:ok, return(descr, args_types, stack)}
       :badmap -> {:error, badremote(:maps, :update, args_types)}
       {:error, _errors} -> {:error, {:badkeydomain, map, key, "raise"}}
@@ -1061,9 +1065,9 @@ defmodule Module.Types.Apply do
           _ -> {map, fun}
         end
 
-      fun_apply = fn _optional?, arg_type ->
+      fun_apply = fn optional?, arg_type ->
         case fun_apply(fun, [arg_type]) do
-          {:ok, res} -> res
+          {:ok, res} -> if optional?, do: if_set(res), else: res
           reason -> throw({:badapply, reason, [arg_type]})
         end
       end

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

@@ -272,6 +272,7 @@ defmodule Module.Types.Descr do
   # If type contains a :dynamic part, :optional gets added there.
   def if_set(type) do
     case type do
+      %{dynamic: :term} -> %{dynamic: term_or_optional()}
       %{dynamic: dyn} -> Map.put(%{type | dynamic: Map.put(dyn, :optional, 1)}, :optional, 1)
       _ -> Map.put(type, :optional, 1)
     end

lib/elixir/test/elixir/map_test.exs

@@ -216,8 +216,7 @@ defmodule MapTest do
     map = %{c: 3, b: 2, a: 1}
     assert Map.replace(map, :b, 10) == %{c: 3, b: 10, a: 1}
     assert Map.replace(map, :a, 1) == map
-    assert Map.replace(map, :x, 1) == map
-    assert Map.replace(%{}, :x, 1) == %{}
+    assert Map.replace(Process.get(:unused, map), :x, 1) == map
   end
 
   test "replace!/3" do

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

@@ -795,6 +795,7 @@ defmodule Module.Types.DescrTest do
       refute subtype?(if_set(none()), term())
       refute subtype?(if_set(term()), term())
       assert subtype?(if_set(term()), if_set(term()))
+      refute subtype?(if_set(term()), if_set(dynamic(term())))
     end
 
     test "list" do

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

@@ -954,7 +954,7 @@ defmodule Module.Types.MapTest do
                closed_map(key: atom([:value]))
 
       assert typecheck!([x], Map.replace(x, :key, :value)) ==
-               dynamic(open_map(key: atom([:value])))
+               dynamic(open_map(key: if_set(atom([:value]))))
 
       # If one of them succeeds, we are still fine!
       assert typecheck!(
@@ -1001,7 +1001,7 @@ defmodule Module.Types.MapTest do
                dynamic(closed_map(key: atom([:value])))
 
       assert typecheck!([x], Map.replace_lazy(x, :key, fn _ -> :value end)) ==
-               dynamic(open_map(key: atom([:value])))
+               dynamic(open_map(key: if_set(atom([:value]))))
 
       # If one of them succeeds, we are still fine!
       assert typecheck!(