Typecheck Map.from_struct/1

Author: josevalim

lib/elixir/lib/map.ex

@@ -1088,6 +1088,7 @@ defmodule Map do
       #=> %{name: "john"}
 
   """
+  # TODO: implement this using row polymorphism
   @spec from_struct(atom | struct) :: map
   def from_struct(struct) when is_atom(struct) do
     IO.warn("Map.from_struct/1 with a module is deprecated, please pass a struct instead")

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

@@ -244,14 +244,15 @@ defmodule Module.Types.Apply do
         {:erlang, :tuple_to_list, [{[open_tuple([])], dynamic(list(term()))}]},
 
         ## Map
-        {:maps, :remove, [{[term(), open_map()], open_map()}]},
+        {Map, :from_struct, [{[open_map()], open_map(__struct__: not_set())}]},
         {:maps, :from_keys, [{[list(term()), term()], open_map()}]},
         {:maps, :find,
          [{[term(), open_map()], tuple([atom([:ok]), term()]) |> union(atom([:error]))}]},
         {:maps, :get, [{[term(), open_map()], term()}]},
         {:maps, :is_key, [{[term(), open_map()], boolean()}]},
         {:maps, :keys, [{[open_map()], dynamic(list(term()))}]},
         {:maps, :put, [{[term(), term(), open_map()], open_map()}]},
+        {:maps, :remove, [{[term(), open_map()], open_map()}]},
         {:maps, :take,
          [{[term(), open_map()], tuple([term(), open_map()]) |> union(atom([:error]))}]},
         {:maps, :to_list, [{[open_map()], dynamic(list(tuple([term(), term()])))}]},
@@ -427,11 +428,13 @@ defmodule Module.Types.Apply do
     end
   end
 
-  defp remote_apply(:maps, :remove, _info, [key, map] = args_types, stack) do
-    case map_update(map, key, not_set(), false, true) do
+  @struct_key atom([:__struct__])
+
+  defp remote_apply(Map, :from_struct, _info, [map] = args_types, stack) do
+    case map_update(map, @struct_key, not_set(), false, true) do
       {_value, descr, _errors} -> {:ok, return(descr, args_types, stack)}
-      :badmap -> {:error, badremote(:maps, :remove, 2)}
-      {:error, _errors} -> {:error, {:badkeydomain, map, key, nil}}
+      :badmap -> {:error, badremote(Map, :from_struct, 1)}
+      {:error, _errors} -> {:error, {:badkeydomain, map, @struct_key, nil}}
     end
   end
 
@@ -472,6 +475,14 @@ defmodule Module.Types.Apply do
     end
   end
 
+  defp remote_apply(:maps, :remove, _info, [key, map] = args_types, stack) do
+    case map_update(map, key, not_set(), false, true) do
+      {_value, descr, _errors} -> {:ok, return(descr, args_types, stack)}
+      :badmap -> {:error, badremote(:maps, :remove, 2)}
+      {: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(), true, false) do
       # We could suggest to use :maps.delete if the key always exists

lib/elixir/src/elixir_compiler.erl

@@ -196,6 +196,7 @@ bootstrap_files() ->
     [
      <<"list/chars.ex">>,
      <<"bitwise.ex">>,
+     <<"map.ex">>,
      <<"module/parallel_checker.ex">>,
      <<"module/behaviour.ex">>,
      <<"module/types/helpers.ex">>,
@@ -208,7 +209,6 @@ bootstrap_files() ->
      <<"exception.ex">>,
      <<"path.ex">>,
      <<"file.ex">>,
-     <<"map.ex">>,
      <<"access.ex">>,
      <<"io.ex">>,
      <<"system.ex">>,

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

@@ -249,6 +249,47 @@ defmodule Module.Types.MapTest do
     end
   end
 
+  describe "Map.from_struct/1" do
+    test "checking" do
+      assert typecheck!(Map.from_struct(%{})) ==
+               closed_map(__struct__: not_set())
+
+      assert typecheck!(Map.from_struct(%{key: 123})) ==
+               closed_map(key: integer(), __struct__: not_set())
+
+      assert typecheck!(Map.from_struct(%URI{})) ==
+               closed_map(
+                 __struct__: not_set(),
+                 authority: atom([nil]),
+                 fragment: atom([nil]),
+                 host: atom([nil]),
+                 path: atom([nil]),
+                 port: atom([nil]),
+                 query: atom([nil]),
+                 scheme: atom([nil]),
+                 userinfo: atom([nil])
+               )
+
+      assert typecheck!([x], Map.from_struct(x)) ==
+               dynamic(open_map(__struct__: not_set()))
+    end
+
+    test "inference" do
+      assert typecheck!(
+               [x],
+               (
+                 _ = Map.from_struct(x)
+                 x
+               )
+             ) == dynamic(open_map())
+    end
+
+    test "errors" do
+      assert typeerror!([x = []], Map.from_struct(x)) =~
+               "incompatible types given to Map.from_struct/1"
+    end
+  end
+
   describe "Map.put/3" do
     test "checking" do
       assert typecheck!(Map.put(%{}, :key, :value)) ==