Type check Map.replace!/3

Author: josevalim

lib/elixir/lib/map.ex

@@ -372,9 +372,7 @@ defmodule Map do
       end
   """
   @spec fetch!(map, key) :: value
-  def fetch!(map, key) do
-    :maps.get(key, map)
-  end
+  def fetch!(map, key), do: :maps.get(key, map)
 
   @doc """
   Puts the given `value` under `key` unless the entry `key`
@@ -432,7 +430,11 @@ defmodule Map do
   @doc """
   Puts a value under `key` only if the `key` already exists in `map`.
 
-  If `key` is not present in `map`, a `KeyError` exception is raised.
+  The exclamation mark (`!`) implies this function can raise a `KeyError`
+  exception at runtime if `map` doesn't contain `key`. If the type system
+  can verify this function will always raise (which means the key is never
+  available), then it will emit a warning at compile-time. See the "Type
+  checking" section in `Map.fetch!/2` for more information.
 
   Inlined by the compiler.
 

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

@@ -253,6 +253,7 @@ defmodule Module.Types.Apply do
         {:maps, :take,
          [{[term(), open_map()], tuple([term(), open_map()]) |> union(atom([:error]))}]},
         {:maps, :to_list, [{[open_map()], dynamic(list(tuple([term(), term()])))}]},
+        {:maps, :update, [{[term(), term(), open_map()], open_map()}]},
         {:maps, :values, [{[open_map()], dynamic(list(term()))}]}
       ] do
     [arity] = Enum.map(clauses, fn {args, _return} -> length(args) end) |> Enum.uniq()
@@ -342,6 +343,12 @@ defmodule Module.Types.Apply do
     {{:strong, nil, [{domain, term()}]}, domain, context}
   end
 
+  def remote_domain(:maps, :update, [key, _, _], _expected, _meta, _stack, context)
+      when is_atom(key) do
+    domain = [term(), term(), open_map([{key, term()}])]
+    {{:strong, nil, [{domain, open_map()}]}, domain, context}
+  end
+
   def remote_domain(mod, fun, args, expected, meta, stack, context) do
     arity = length(args)
 
@@ -459,6 +466,14 @@ defmodule Module.Types.Apply do
     end
   end
 
+  defp remote_apply(:maps, :update, _info, [key, value, map] = args_types, stack) do
+    case map_update(map, key, value, false) do
+      {_value, descr, _errors} -> {:ok, return(descr, args_types, stack)}
+      :badmap -> {:error, badremote(:maps, :update, 3)}
+      {:error, _errors} -> {:error, {:badkeydomain, map, key, nil}}
+    end
+  end
+
   defp remote_apply(:maps, :take, _info, [key, map] = args_types, stack) do
     case map_update(map, key, not_set()) do
       # We could suggest to use :maps.delete if the key always exists

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

@@ -190,6 +190,53 @@ defmodule Module.Types.MapTest do
     end
   end
 
+  describe "Map.replace!/3" do
+    test "checking" do
+      assert typecheck!(Map.replace!(%{key: 123}, :key, :value)) ==
+               closed_map(key: atom([:value]))
+
+      assert typecheck!([x], Map.replace!(x, :key, :value)) ==
+               dynamic(open_map(key: atom([:value])))
+
+      # If one of them succeeds, we are still fine!
+      assert typecheck!(
+               [condition?],
+               Map.replace!(%{foo: 123}, if(condition?, do: :foo, else: :bar), :value)
+             ) == closed_map(foo: atom([:value]))
+
+      assert typecheck!([x], Map.replace!(x, 123, 456)) == dynamic(open_map())
+    end
+
+    test "inference" do
+      assert typecheck!(
+               [x],
+               (
+                 _ = Map.replace!(x, :key, :value)
+                 x
+               )
+             ) == dynamic(open_map(key: term()))
+    end
+
+    test "errors" do
+      assert typeerror!(Map.replace!(%{}, :key, :value)) =~
+               """
+               incompatible types given to Map.replace!/3:
+
+                   Map.replace!(%{}, :key, :value)
+
+               the map:
+
+                   empty_map()
+
+               does not have all required keys:
+
+                   :key
+
+               therefore this function will always raise
+               """
+    end
+  end
+
   describe "Map.to_list/1" do
     test "checking" do
       assert typecheck!([x = %{}], Map.to_list(x)) == dynamic(list(tuple([term(), term()])))