Type Map.to_list/1, Map.keys/1, and Map.values/1

Author: josevalim

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

@@ -241,7 +241,12 @@ defmodule Module.Types.Apply do
         {:erlang, :send, [{[send_destination, term()], dynamic()}]},
         {:erlang, :setelement, [{[integer(), open_tuple([]), term()], dynamic(open_tuple([]))}]},
         {:erlang, :tl, [{[non_empty_list(term(), term())], dynamic()}]},
-        {:erlang, :tuple_to_list, [{[open_tuple([])], dynamic(list(term()))}]}
+        {:erlang, :tuple_to_list, [{[open_tuple([])], dynamic(list(term()))}]},
+
+        ## Map
+        {:maps, :keys, [{[open_map()], dynamic(list(term()))}]},
+        {:maps, :to_list, [{[open_map()], dynamic(list(tuple([term(), term()])))}]},
+        {:maps, :values, [{[open_map()], dynamic(list(term()))}]}
       ] do
     [arity] = Enum.map(clauses, fn {args, _return} -> length(args) end) |> Enum.uniq()
 
@@ -314,14 +319,6 @@ defmodule Module.Types.Apply do
     {{:make_tuple, size}, [integer(), term()], context}
   end
 
-  def remote_domain(:erlang, :hd, [_list], expected, _meta, _stack, context) do
-    {:hd, [non_empty_list(expected, term())], context}
-  end
-
-  def remote_domain(:erlang, :tl, [_list], _expected, _meta, _stack, context) do
-    {:tl, [non_empty_list(term(), term())], context}
-  end
-
   def remote_domain(:erlang, name, [_left, _right], _expected, _meta, stack, context)
       when name in [:>=, :"=<", :>, :<, :min, :max] do
     {{:ordered_compare, name, is_warning(stack)}, [term(), term()], context}
@@ -350,7 +347,7 @@ defmodule Module.Types.Apply do
   Applies a previously collected domain from `remote_domain/7`.
   """
   def remote_apply(info, mod, fun, args_types, expr, stack, context) do
-    case remote_apply(info, args_types, stack) do
+    case remote_apply(mod, fun, info, args_types, stack) do
       {:ok, type} ->
         {type, context}
 
@@ -361,6 +358,45 @@ defmodule Module.Types.Apply do
     end
   end
 
+  defp remote_apply(:erlang, :hd, _info, [list], _stack) do
+    case list_hd(list) do
+      {_, value_type} -> {:ok, value_type}
+      :badnonemptylist -> {:error, badremote(:erlang, :hd, 1)}
+    end
+  end
+
+  defp remote_apply(:erlang, :tl, _info, [list], _stack) do
+    case list_tl(list) do
+      {_, value_type} -> {:ok, value_type}
+      :badnonemptylist -> {:error, badremote(:erlang, :tl, 1)}
+    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, list_type}
+      :badmap -> {:error, badremote(:maps, :keys, 1)}
+    end
+  end
+
+  defp remote_apply(:maps, :values, _info, [map], _stack) do
+    case map_to_list(map, fn _key, value -> value end) do
+      {:ok, list_type} -> {:ok, list_type}
+      :badmap -> {:error, badremote(:maps, :keys, 1)}
+    end
+  end
+
+  defp remote_apply(:maps, :to_list, _info, [map], _stack) do
+    case map_to_list(map) do
+      {:ok, list_type} -> {:ok, list_type}
+      :badmap -> {:error, badremote(:maps, :to_list, 1)}
+    end
+  end
+
+  defp remote_apply(_mod, _fun, info, args_types, stack) do
+    remote_apply(info, args_types, stack)
+  end
+
   defp remote_apply(:none, _args_types, _stack) do
     {:ok, dynamic()}
   end
@@ -407,20 +443,6 @@ defmodule Module.Types.Apply do
     {:ok, tuple(List.duplicate(elem, size))}
   end
 
-  defp remote_apply(:hd, [list], _stack) do
-    case list_hd(list) do
-      {_, value_type} -> {:ok, value_type}
-      :badnonemptylist -> {:error, badremote(:erlang, :hd, 1)}
-    end
-  end
-
-  defp remote_apply(:tl, [list], _stack) do
-    case list_tl(list) do
-      {_, value_type} -> {:ok, value_type}
-      :badnonemptylist -> {:error, badremote(:erlang, :tl, 1)}
-    end
-  end
-
   defp remote_apply({:ordered_compare, name, check?}, [left, right], stack) do
     result =
       if name in [:min, :max] do

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

@@ -2750,22 +2750,24 @@ defmodule Module.Types.Descr do
   @doc """
   Returns the map converted into a list.
   """
-  def map_to_list(:term), do: :badmap
+  def map_to_list(descr, fun \\ &tuple([&1, &2]))
 
-  def map_to_list(descr) do
+  def map_to_list(:term, _fun), do: :badmap
+
+  def map_to_list(descr, fun) do
     case :maps.take(:dynamic, descr) do
       :error ->
-        if descr_key?(descr, :map) and map_only?(descr) do
-          map_to_list_static(descr.map)
+        if map_only?(descr) do
+          map_to_list_static(descr, fun)
         else
           :badmap
         end
 
       {dynamic, static} ->
-        if descr_key?(dynamic, :map) and map_only?(static) do
-          with {:ok, dynamic_type} <- map_to_list_static(dynamic.map) do
+        if map_only?(static) do
+          with {:ok, dynamic_type} <- map_to_list_static(dynamic, fun) do
             if descr_key?(static, :map) do
-              with {:ok, static_type} <- map_to_list_static(static.map) do
+              with {:ok, static_type} <- map_to_list_static(static, fun) do
                 {:ok, union(static_type, dynamic(dynamic_type))}
               end
             else
@@ -2778,13 +2780,13 @@ defmodule Module.Types.Descr do
     end
   end
 
-  defp map_to_list_static(bdd) do
+  defp map_to_list_static(%{map: bdd}, fun) do
     case map_bdd_to_dnf(bdd) do
       [] ->
         :badmap
 
       dnf ->
-        case map_to_list_static(bdd, dnf) do
+        case map_to_list_static(bdd, dnf, fun) do
           value when value == @none ->
             {:ok, empty_list()}
 
@@ -2798,6 +2800,14 @@ defmodule Module.Types.Descr do
     end
   end
 
+  defp map_to_list_static(%{}, _fun) do
+    :badmap
+  end
+
+  defp map_to_list_static(:term, fun) do
+    {:ok, list(fun.(term(), term()))}
+  end
+
   defp has_empty_map?(dnf) do
     Enum.any?(dnf, fn {_, fields, negs} ->
       Enum.all?(fields, fn {_key, value} -> optional_static?(value) end) and
@@ -2807,7 +2817,7 @@ defmodule Module.Types.Descr do
     end)
   end
 
-  defp map_to_list_static(bdd, dnf) do
+  defp map_to_list_static(bdd, dnf, fun) do
     try do
       # Check if any line in the DNF represents an open map or compute the union of domain keys types
       Enum.reduce(dnf, none(), fn
@@ -2825,7 +2835,7 @@ defmodule Module.Types.Descr do
                 if empty?(value) do
                   acc
                 else
-                  union(acc, tuple([domain_key_to_descr(domain_key), value]))
+                  union(acc, fun.(domain_key_to_descr(domain_key), value))
                 end
               end)
 
@@ -2834,7 +2844,7 @@ defmodule Module.Types.Descr do
           end
       end)
     catch
-      :open -> tuple([term(), term()])
+      :open -> fun.(term(), term())
     else
       domain_keys_type ->
         {_seen, acc} =
@@ -2849,7 +2859,7 @@ defmodule Module.Types.Descr do
                 if empty?(value) do
                   {seen, acc}
                 else
-                  {seen, union(acc, tuple([atom([key]), value]))}
+                  {seen, union(acc, fun.(atom([key]), value))}
                 end
               end
             end)

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

@@ -1514,6 +1514,7 @@ defmodule Module.Types.DescrTest do
       assert map_to_list(integer()) == :badmap
       assert map_to_list(union(open_map(), integer())) == :badmap
       assert map_to_list(none()) == :badmap
+      assert map_to_list(dynamic()) == {:ok, dynamic(list(tuple([term(), term()])))}
 
       # A non existent map type is refused
       assert open_map()

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

@@ -0,0 +1,181 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: 2021 The Elixir Team
+# SPDX-FileCopyrightText: 2012 Plataformatec
+
+Code.require_file("type_helper.exs", __DIR__)
+
+defmodule Module.Types.MapTest do
+  # Tests for the Map module
+  use ExUnit.Case, async: true
+
+  import TypeHelper
+  import Module.Types.Descr
+  defmacro domain_key(arg) when is_atom(arg), do: [arg]
+
+  describe "Map.to_list/1" do
+    test "checking" do
+      assert typecheck!([x = %{}], Map.to_list(x)) == dynamic(list(tuple([term(), term()])))
+
+      assert typecheck!(
+               (
+                 x = %{}
+                 Map.to_list(x)
+               )
+             ) == empty_list()
+
+      assert typecheck!(
+               (
+                 x = %{"c" => :three}
+                 Map.to_list(x)
+               )
+             ) ==
+               list(tuple([binary(), atom([:three])]))
+
+      assert typecheck!(
+               (
+                 x = %{a: 1, b: "two"}
+                 Map.to_list(x)
+               )
+             ) ==
+               non_empty_list(
+                 union(tuple([atom([:a]), integer()]), tuple([atom([:b]), binary()]))
+               )
+
+      assert typecheck!(
+               (
+                 x = %{"c" => :three, a: 1, b: "two"}
+                 Map.to_list(x)
+               )
+             ) ==
+               non_empty_list(
+                 tuple([atom([:a]), integer()])
+                 |> union(tuple([atom([:b]), binary()]))
+                 |> union(tuple([binary(), atom([:three])]))
+               )
+    end
+
+    test "inference" do
+      assert typecheck!(
+               [x],
+               (
+                 _ = Map.to_list(x)
+                 x
+               )
+             ) == dynamic(open_map())
+    end
+
+    test "errors" do
+      assert typeerror!([x = []], Map.to_list(x)) =~ "incompatible types given to Map.to_list/1"
+    end
+  end
+
+  describe "Map.keys/1" do
+    test "checking" do
+      assert typecheck!([x = %{}], Map.keys(x)) == dynamic(list(term()))
+
+      assert typecheck!(
+               (
+                 x = %{}
+                 Map.keys(x)
+               )
+             ) == empty_list()
+
+      assert typecheck!(
+               (
+                 x = %{"c" => :three}
+                 Map.keys(x)
+               )
+             ) ==
+               list(binary())
+
+      assert typecheck!(
+               (
+                 x = %{a: 1, b: "two"}
+                 Map.keys(x)
+               )
+             ) ==
+               non_empty_list(union(atom([:a]), atom([:b])))
+
+      assert typecheck!(
+               (
+                 x = %{"c" => :three, a: 1, b: "two"}
+                 Map.keys(x)
+               )
+             ) ==
+               non_empty_list(
+                 atom([:a])
+                 |> union(atom([:b]))
+                 |> union(binary())
+               )
+    end
+
+    test "inference" do
+      assert typecheck!(
+               [x],
+               (
+                 _ = Map.keys(x)
+                 x
+               )
+             ) == dynamic(open_map())
+    end
+
+    test "errors" do
+      assert typeerror!([x = []], Map.keys(x)) =~ "incompatible types given to Map.keys/1"
+    end
+  end
+
+  describe "Map.values/1" do
+    test "checking" do
+      assert typecheck!([x = %{}], Map.values(x)) == dynamic(list(term()))
+
+      assert typecheck!(
+               (
+                 x = %{}
+                 Map.values(x)
+               )
+             ) == empty_list()
+
+      assert typecheck!(
+               (
+                 x = %{"c" => :three}
+                 Map.values(x)
+               )
+             ) ==
+               list(atom([:three]))
+
+      assert typecheck!(
+               (
+                 x = %{a: 1, b: "two"}
+                 Map.values(x)
+               )
+             ) ==
+               non_empty_list(union(integer(), binary()))
+
+      assert typecheck!(
+               (
+                 x = %{"c" => :three, a: 1, b: "two"}
+                 Map.values(x)
+               )
+             ) ==
+               non_empty_list(
+                 integer()
+                 |> union(binary())
+                 |> union(atom([:three]))
+               )
+    end
+
+    test "inference" do
+      assert typecheck!(
+               [x],
+               (
+                 _ = Map.values(x)
+                 x
+               )
+             ) == dynamic(open_map())
+    end
+
+    test "errors" do
+      assert typeerror!([x = []], Map.values(x)) =~ "incompatible types given to Map.values/1"
+    end
+  end
+end