Add type checking for Map.from_keys/2

Author: josevalim

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

@@ -244,6 +244,8 @@ defmodule Module.Types.Apply do
         {:erlang, :tuple_to_list, [{[open_tuple([])], dynamic(list(term()))}]},
 
         ## Map
+        {:maps, :from_keys, [{[list(term()), term()], open_map()}]},
+        {:maps, :is_key, [{[term(), open_map()], boolean()}]},
         {:maps, :keys, [{[open_map()], dynamic(list(term()))}]},
         {:maps, :to_list, [{[open_map()], dynamic(list(tuple([term(), term()])))}]},
         {:maps, :values, [{[open_map()], dynamic(list(term()))}]}
@@ -372,6 +374,40 @@ defmodule Module.Types.Apply do
     end
   end
 
+  defp remote_apply(:maps, :from_keys, _info, [list, value_type] = args_types, stack) do
+    case list_of(list) do
+      {true, nil} ->
+        {:ok, return(empty_map(), args_types, stack)}
+
+      {empty_list?, key_type} ->
+        if key_type == dynamic() or key_type == term() do
+          {:ok, return(open_map(), args_types, stack)}
+        else
+          value_type = if_set(value_type)
+          domain_keys = to_domain_keys(key_type)
+
+          keys =
+            case atom_fetch(key_type) do
+              {:finite, atom_keys} -> [List.delete(domain_keys, :atom) | atom_keys]
+              _ -> [domain_keys]
+            end
+
+          map = closed_map(Enum.map(keys, &{&1, value_type}))
+
+          map_and_maybe_empty_map =
+            case empty_list? do
+              true -> map
+              false -> difference(map, empty_map())
+            end
+
+          {:ok, return(map_and_maybe_empty_map, args_types, stack)}
+        end
+
+      :badproperlist ->
+        {:error, badremote(:maps, :from_keys, 2)}
+    end
+  end
+
   defp remote_apply(:maps, :keys, _info, [map], stack) do
     case map_to_list(map, fn key, _value -> key end) do
       {:ok, list_type} -> {:ok, return(list_type, [map], stack)}

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

@@ -1884,32 +1884,33 @@ defmodule Module.Types.Descr do
   It returns a two-element tuple. The first element dictates the
   empty list type. The second element returns the value type.
 
-      {:static or :dynamic or nil, t() or nil}
+      {boolean(), t() or nil}
 
   If the value is `nil`, it means that component is missing.
-  However, both cannot be `nil` together. In such cases,
-  we return `:badproperlist`.
+  Note `{false, nil}` is not a valid return type, instead it
+  returns `:badproperlist`.
   """
   def list_of(:term), do: :badproperlist
 
   def list_of(descr) do
     case :maps.take(:dynamic, descr) do
       :error ->
-        with {empty_list, value} <- list_of_static(descr) do
-          if empty?(value) and empty_list == nil do
+        with {empty_list?, value} <- list_of_static(descr) do
+          if empty?(value) and empty_list? == false do
             :badproperlist
           else
-            {empty_list, value}
+            {empty_list?, value}
           end
         end
 
       {dynamic, static} ->
-        with {empty_list, static_value} <- list_of_static(static) do
-          empty_list =
-            case dynamic do
-              %{bitmap: bitmap} when (bitmap &&& @bit_empty_list) != 0 -> :dynamic
-              _ -> empty_list
-            end
+        with {empty_list?, static_value} <- list_of_static(static) do
+          empty_list? =
+            empty_list? or
+              match?(
+                %{bitmap: bitmap} when (bitmap &&& @bit_empty_list) != 0,
+                dynamic
+              )
 
           dynamic_value =
             case dynamic do
@@ -1932,13 +1933,12 @@ defmodule Module.Types.Descr do
           if empty?(dynamic_value) do
             # list_bdd_to_pos_dnf guarantees the lists actually exists,
             # so we can match on none() rather than empty.
-            if empty_list == nil do
-              :badproperlist
-            else
-              {empty_list, nil}
+            case empty_list? do
+              false -> :badproperlist
+              true -> {empty_list?, nil}
             end
           else
-            {empty_list, union(static_value, dynamic(dynamic_value))}
+            {empty_list?, union(static_value, dynamic(dynamic_value))}
           end
         end
     end
@@ -1948,7 +1948,7 @@ defmodule Module.Types.Descr do
     case descr do
       %{bitmap: @bit_empty_list} ->
         case empty?(Map.drop(descr, [:bitmap, :list])) do
-          true -> list_of_static(descr, :static)
+          true -> list_of_static(descr, true)
           false -> :badproperlist
         end
 
@@ -1957,7 +1957,7 @@ defmodule Module.Types.Descr do
 
       %{} ->
         case empty?(Map.delete(descr, :list)) do
-          true -> list_of_static(descr, nil)
+          true -> list_of_static(descr, false)
           false -> :badproperlist
         end
     end

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

@@ -1271,18 +1271,18 @@ defmodule Module.Types.DescrTest do
     test "list_of" do
       assert list_of(term()) == :badproperlist
       assert list_of(none()) == :badproperlist
-      assert list_of(empty_list()) == {:static, none()}
+      assert list_of(empty_list()) == {true, none()}
       assert list_of(union(empty_list(), integer())) == :badproperlist
-      assert list_of(non_empty_list(integer())) == {nil, integer()}
+      assert list_of(non_empty_list(integer())) == {false, integer()}
       assert list_of(non_empty_list(integer(), atom())) == :badproperlist
       assert list_of(non_empty_list(integer(), term())) == :badproperlist
-      assert list_of(non_empty_list(integer(), list(term()))) == {nil, term()}
+      assert list_of(non_empty_list(integer(), list(term()))) == {false, term()}
       assert list_of(list(integer()) |> union(list(integer(), integer()))) == :badproperlist
       assert list_of(list(integer()) |> union(integer())) == :badproperlist
-      assert list_of(dynamic(list(integer()))) == {:dynamic, dynamic(integer())}
-      assert list_of(dynamic(list(integer(), atom()))) == {:dynamic, nil}
+      assert list_of(dynamic(list(integer()))) == {true, dynamic(integer())}
+      assert list_of(dynamic(list(integer(), atom()))) == {true, nil}
       assert list_of(dynamic(non_empty_list(integer(), atom()))) == :badproperlist
-      assert list_of(dynamic(union(empty_list(), integer()))) == {:dynamic, nil}
+      assert list_of(dynamic(union(empty_list(), integer()))) == {true, nil}
 
       # A list that the difference resolves to nothing
       list_with_tail =

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

@@ -69,6 +69,52 @@ defmodule Module.Types.MapTest do
     end
   end
 
+  describe "Map.from_keys/2" do
+    test "checking" do
+      assert typecheck!([], Map.from_keys([], :value)) ==
+               empty_map()
+
+      assert typecheck!([x], Map.from_keys(x, :value)) ==
+               open_map()
+
+      assert typecheck!(
+               (
+                 x = [:key1, :key2]
+                 Map.from_keys(x, 123)
+               )
+             ) ==
+               closed_map(key1: if_set(integer()), key2: if_set(integer()))
+               |> difference(empty_map())
+
+      assert typecheck!(
+               [condition?],
+               (
+                 x = if condition?, do: [123, "123"], else: []
+                 Map.from_keys(x, 123)
+               )
+             ) ==
+               closed_map([
+                 {domain_key(:integer), if_set(integer())},
+                 {domain_key(:binary), if_set(integer())}
+               ])
+    end
+
+    test "inference" do
+      assert typecheck!(
+               [x],
+               (
+                 _ = Map.from_keys(x, :value)
+                 x
+               )
+             ) == dynamic(list(term()))
+    end
+
+    test "errors" do
+      assert typeerror!([x = %{}], Map.from_keys(x, :value)) =~
+               "incompatible types given to Map.from_keys/2"
+    end
+  end
+
   describe "Map.keys/1" do
     test "checking" do
       assert typecheck!([x = %{}], Map.keys(x)) == dynamic(list(term()))